From d55d13a7d7dd052e587fcb25530a8b91d04fa957 Mon Sep 17 00:00:00 2001 From: openharmony_ci <120357966@qq.com> Date: Wed, 10 Jul 2024 13:28:12 +0000 Subject: [PATCH] =?UTF-8?q?=E5=9B=9E=E9=80=80=20'Pull=20Request=20!144=20:?= =?UTF-8?q?=20=E5=8D=87=E7=BA=A7libuv=E5=88=B01.48.0=E7=89=88=E6=9C=AC'?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .github/stale.yml | 23 + .github/workflows/CI-docs.yml | 25 - .github/workflows/CI-unix.yml | 29 +- .github/workflows/CI-win.yml | 105 +- .github/workflows/sanitizer.yml | 92 +- .gitignore | 4 - .mailmap | 3 - .readthedocs.yaml | 6 +- AUTHORS | 50 - BUILD.gn | 23 +- CMakeLists.txt | 222 +- ChangeLog | 555 +--- LICENSE | 47 + LICENSE-extra | 36 - LINKS.md | 12 +- MAINTAINERS.md | 14 +- Makefile.am | 31 +- README.md | 13 +- SECURITY.md | 27 - SUPPORTED_PLATFORMS.md | 6 +- autogen.sh | 2 +- cmake-toolchains/cross-mingw32.cmake | 17 - configure.ac | 15 +- docs/requirements.txt | 66 +- docs/src/conf.py | 2 +- docs/src/design.rst | 17 +- docs/src/errors.rst | 3 - docs/src/fs.rst | 23 +- docs/src/fs_event.rst | 8 +- docs/src/guide/networking.rst | 3 +- docs/src/guide/processes.rst | 5 +- docs/src/guide/utilities.rst | 4 +- docs/src/handle.rst | 3 - docs/src/metrics.rst | 48 +- docs/src/misc.rst | 132 +- docs/src/pipe.rst | 54 +- docs/src/poll.rst | 4 +- docs/src/process.rst | 12 +- docs/src/static/loop_iteration.png | Bin 65186 -> 80528 bytes docs/src/threading.rst | 55 - docs/src/threadpool.rst | 3 - docs/src/udp.rst | 2 +- include/uv.h | 132 +- include/uv/darwin.h | 6 +- include/uv/errno.h | 19 +- include/uv/linux.h | 2 +- include/uv/stdint-msvc2008.h | 247 ++ include/uv/threadpool.h | 6 +- include/uv/unix.h | 54 +- include/uv/version.h | 4 +- include/uv/win.h | 42 +- libuv-static.pc.in | 2 +- libuv.pc.in | 1 - m4/.gitignore | 5 - m4/as_case.m4 | 21 - m4/ax_pthread.m4 | 485 --- m4/libuv-check-flags.m4 | 336 --- src/idna.c | 245 +- src/idna.h | 4 +- src/inet.c | 9 +- src/queue.h | 178 +- src/random.c | 4 +- src/thread-common.c | 175 -- src/threadpool.c | 163 +- src/timer.c | 46 +- src/unix/aix.c | 34 +- src/unix/async.c | 52 +- src/unix/atomic-ops.h | 64 + src/unix/core.c | 380 +-- src/unix/cygwin.c | 4 - src/unix/darwin-stub.h | 16 + src/unix/darwin.c | 168 +- src/unix/epoll.c | 472 +++ src/unix/freebsd.c | 33 +- src/unix/fs.c | 415 +-- src/unix/fsevents.c | 115 +- src/unix/haiku.c | 5 - src/unix/hurd.c | 5 - src/unix/ibmi.c | 5 - src/unix/internal.h | 168 +- src/unix/kqueue.c | 177 +- src/unix/linux-core.c | 834 ++++++ src/unix/linux-inotify.c | 327 +++ src/unix/linux-syscalls.c | 264 ++ .../unix/linux-syscalls.h | 143 +- src/unix/linux.c | 2597 ----------------- src/unix/loop-watcher.c | 20 +- src/unix/loop.c | 53 +- src/unix/netbsd.c | 9 +- src/unix/openbsd.c | 9 +- src/unix/os390-syscalls.c | 24 +- src/unix/os390-syscalls.h | 2 +- src/unix/os390.c | 46 +- src/unix/pipe.c | 139 +- src/unix/posix-hrtime.c | 13 +- src/unix/posix-poll.c | 27 +- src/unix/process.c | 82 +- src/unix/pthread-fixes.c | 58 + src/unix/qnx.c | 5 - src/unix/random-devurandom.c | 2 +- src/unix/random-getrandom.c | 2 + src/unix/signal.c | 25 +- src/unix/spinlock.h | 53 + src/unix/stream.c | 241 +- src/unix/sunos.c | 25 +- src/unix/tcp.c | 328 +-- src/unix/thread.c | 251 +- src/unix/tty.c | 26 +- src/unix/udp.c | 166 +- src/uv-common.c | 102 +- src/uv-common.h | 86 +- src/win/core.c | 73 +- src/win/dl.c | 15 +- src/win/fs-event.c | 30 +- src/win/fs.c | 373 +-- src/win/getaddrinfo.c | 156 +- src/win/getnameinfo.c | 29 +- src/win/handle-inl.h | 2 +- src/win/internal.h | 20 +- src/win/pipe.c | 341 +-- src/win/poll.c | 5 +- src/win/process.c | 399 +-- src/win/stream.c | 3 +- src/win/tcp.c | 48 +- src/win/thread.c | 139 +- src/win/tty.c | 111 +- src/win/udp.c | 213 +- src/win/util.c | 762 +++-- test/benchmark-async-pummel.c | 15 +- test/benchmark-async.c | 37 +- test/benchmark-fs-stat.c | 12 +- test/benchmark-getaddrinfo.c | 10 +- test/benchmark-list.h | 2 - test/benchmark-loop-count.c | 48 +- test/benchmark-million-async.c | 21 +- test/benchmark-million-timers.c | 14 +- test/benchmark-multi-accept.c | 116 +- test/benchmark-ping-pongs.c | 28 +- test/benchmark-ping-udp.c | 14 +- test/benchmark-pound.c | 14 +- test/benchmark-pump.c | 56 +- test/benchmark-queue-work.c | 19 +- test/benchmark-spawn.c | 24 +- test/benchmark-tcp-write-batch.c | 32 +- test/benchmark-thread.c | 8 +- test/benchmark-udp-pummel.c | 62 +- test/blackhole-server.c | 22 +- test/echo-server.c | 34 +- test/fixtures/one_file/one_file | 0 test/run-tests.c | 45 +- test/runner-unix.c | 15 +- test/runner-win.c | 6 +- test/runner.c | 30 +- test/task.h | 38 +- test/test-active.c | 34 +- test/test-async-null-cb.c | 18 +- test/test-async.c | 28 +- test/test-barrier.c | 58 +- test/test-callback-stack.c | 39 +- test/test-close-fd.c | 38 +- test/test-close-order.c | 20 +- test/test-condvar.c | 59 +- test/test-connect-unspecified.c | 31 +- test/test-connection-fail.c | 38 +- test/test-cwd-and-chdir.c | 18 +- test/test-default-loop-close.c | 21 +- test/test-delayed-accept.c | 42 +- test/test-dlerror.c | 21 +- test/test-eintr-handling.c | 26 +- test/test-embed.c | 12 +- test/test-emfile.c | 32 +- test/test-env-vars.c | 73 +- test/test-error.c | 26 +- test/test-fork.c | 314 +- test/test-fs-copyfile.c | 81 +- test/test-fs-event.c | 414 ++- test/test-fs-fd-hash.c | 6 +- test/test-fs-open-flags.c | 98 +- test/test-fs-poll.c | 128 +- test/test-fs-readdir.c | 164 +- test/test-fs.c | 2322 +++++++-------- test/test-get-currentexe.c | 29 +- test/test-get-loadavg.c | 6 +- test/test-get-memory.c | 21 +- test/test-get-passwd.c | 162 +- test/test-getaddrinfo.c | 175 +- test/test-gethostname.c | 16 +- test/test-getnameinfo.c | 73 +- test/test-getsockname.c | 72 +- test/test-getters-setters.c | 51 +- test/test-gettimeofday.c | 6 +- test/test-handle-fileno.c | 44 +- test/test-homedir.c | 28 +- test/test-hrtime.c | 15 +- test/test-idle.c | 42 +- test/test-idna.c | 82 +- test/test-ip-name.c | 24 +- test/test-ip4-addr.c | 30 +- test/test-ip6-addr.c | 56 +- test/test-ipc-heavy-traffic-deadlock-bug.c | 28 +- test/test-ipc-send-recv.c | 120 +- test/test-ipc.c | 230 +- test/test-list.h | 80 - test/test-loop-alive.c | 9 +- test/test-loop-close.c | 28 +- test/test-loop-configure.c | 14 +- test/test-loop-handles.c | 74 +- test/test-loop-stop.c | 30 +- test/test-loop-time.c | 24 +- test/test-metrics.c | 295 +- test/test-multiple-listen.c | 28 +- test/test-mutexes.c | 44 +- ...-not-readable-nor-writable-on-read-error.c | 38 +- test/test-not-writable-after-shutdown.c | 18 +- test/test-osx-select.c | 24 +- test/test-ping-pong.c | 74 +- test/test-pipe-bind-error.c | 92 +- test/test-pipe-close-stdout-read-stdin.c | 26 +- test/test-pipe-connect-error.c | 26 +- test/test-pipe-connect-multiple.c | 95 +- test/test-pipe-connect-prepare.c | 18 +- test/test-pipe-getsockname.c | 202 +- test/test-pipe-pending-instances.c | 10 +- test/test-pipe-sendmsg.c | 42 +- test/test-pipe-server-close.c | 26 +- test/test-pipe-set-fchmod.c | 24 +- test/test-pipe-set-non-blocking.c | 38 +- test/test-platform-output.c | 72 +- test/test-poll-close-doesnt-corrupt-stack.c | 26 +- test/test-poll-close.c | 6 +- test/test-poll-closesocket.c | 26 +- test/test-poll-multiple-handles.c | 35 +- test/test-poll-oob.c | 92 +- test/test-poll.c | 125 +- test/test-process-priority.c | 26 +- test/test-process-title-threadsafe.c | 23 +- test/test-process-title.c | 28 +- test/test-queue-foreach-delete.c | 43 +- test/test-random.c | 46 +- test/test-readable-on-eof.c | 39 +- test/test-ref.c | 106 +- test/test-run-nowait.c | 7 +- test/test-run-once.c | 6 +- test/test-semaphore.c | 30 +- test/test-shutdown-close.c | 40 +- test/test-shutdown-eof.c | 54 +- test/test-shutdown-simultaneous.c | 30 +- test/test-shutdown-twice.c | 24 +- test/test-signal-multiple-loops.c | 106 +- test/test-signal-pending-on-close.c | 45 +- test/test-signal.c | 156 +- test/test-socket-buffer-size.c | 24 +- test/test-spawn.c | 793 ++--- test/test-stdio-over-pipes.c | 74 +- test/test-strscpy.c | 25 +- test/test-strtok.c | 29 +- test/test-tcp-alloc-cb-fail.c | 52 +- test/test-tcp-bind-error.c | 140 +- test/test-tcp-bind6-error.c | 58 +- test/test-tcp-close-accept.c | 70 +- test/test-tcp-close-after-read-timeout.c | 50 +- test/test-tcp-close-reset.c | 142 +- test/test-tcp-close-while-connecting.c | 28 +- test/test-tcp-close.c | 36 +- test/test-tcp-connect-error-after-write.c | 36 +- test/test-tcp-connect-error.c | 10 +- test/test-tcp-connect-timeout.c | 50 +- test/test-tcp-connect6-error.c | 68 +- test/test-tcp-create-socket-early.c | 76 +- test/test-tcp-flags.c | 10 +- test/test-tcp-oob.c | 58 +- test/test-tcp-open.c | 142 +- test/test-tcp-read-stop-start.c | 46 +- test/test-tcp-read-stop.c | 40 +- test/test-tcp-rst.c | 25 +- test/test-tcp-shutdown-after-write.c | 36 +- test/test-tcp-try-write-error.c | 42 +- test/test-tcp-try-write.c | 44 +- test/test-tcp-unexpected-read.c | 52 +- test/test-tcp-write-after-connect.c | 30 +- test/test-tcp-write-fail.c | 26 +- test/test-tcp-write-in-a-row.c | 143 - test/test-tcp-write-queue-order.c | 56 +- test/test-tcp-write-to-half-open-connection.c | 38 +- test/test-tcp-writealot.c | 47 +- test/test-thread-affinity.c | 154 - test/test-thread-equal.c | 14 +- test/test-thread.c | 149 +- test/test-threadpool-cancel.c | 249 +- test/test-threadpool.c | 26 +- test/test-timer-again.c | 40 +- test/test-timer-from-check.c | 52 +- test/test-timer.c | 247 +- test/test-tmpdir.c | 28 +- test/test-tty-duplicate-key.c | 66 +- test/test-tty-escape-sequence-processing.c | 247 +- test/test-tty.c | 166 +- test/test-udp-alloc-cb-fail.c | 58 +- test/test-udp-bind.c | 28 +- test/test-udp-connect.c | 77 +- test/test-udp-connect6.c | 59 +- test/test-udp-create-socket-early.c | 56 +- test/test-udp-dgram-too-big.c | 22 +- test/test-udp-ipv6.c | 78 +- test/test-udp-mmsg.c | 30 +- test/test-udp-multicast-interface.c | 28 +- test/test-udp-multicast-interface6.c | 28 +- test/test-udp-multicast-join.c | 51 +- test/test-udp-multicast-join6.c | 51 +- test/test-udp-multicast-ttl.c | 24 +- test/test-udp-open.c | 106 +- test/test-udp-options.c | 60 +- test/test-udp-recv-in-a-row.c | 121 - test/test-udp-send-and-recv.c | 64 +- test/test-udp-send-hang-loop.c | 22 +- test/test-udp-send-immediate.c | 36 +- test/test-udp-send-unreachable.c | 40 +- test/test-udp-sendmmsg-error.c | 12 +- test/test-udp-try-send.c | 36 +- test/test-uname.c | 18 +- test/test-walk-handles.c | 18 +- test/test-watcher-cross-stop.c | 32 +- tsansupp.txt | 2 - 323 files changed, 11605 insertions(+), 17127 deletions(-) create mode 100644 .github/stale.yml delete mode 100644 .github/workflows/CI-docs.yml delete mode 100644 LICENSE-extra delete mode 100644 SECURITY.md delete mode 100644 cmake-toolchains/cross-mingw32.cmake create mode 100644 include/uv/stdint-msvc2008.h delete mode 100644 m4/.gitignore delete mode 100644 m4/as_case.m4 delete mode 100644 m4/ax_pthread.m4 delete mode 100644 m4/libuv-check-flags.m4 delete mode 100644 src/thread-common.c create mode 100644 src/unix/atomic-ops.h create mode 100644 src/unix/epoll.c create mode 100644 src/unix/linux-core.c create mode 100644 src/unix/linux-inotify.c create mode 100644 src/unix/linux-syscalls.c rename test/test-thread-priority.c => src/unix/linux-syscalls.h (36%) delete mode 100644 src/unix/linux.c create mode 100644 src/unix/pthread-fixes.c create mode 100644 src/unix/spinlock.h delete mode 100644 test/fixtures/one_file/one_file delete mode 100644 test/test-tcp-write-in-a-row.c delete mode 100644 test/test-thread-affinity.c delete mode 100644 test/test-udp-recv-in-a-row.c delete mode 100644 tsansupp.txt diff --git a/.github/stale.yml b/.github/stale.yml new file mode 100644 index 0000000..6f2fb66 --- /dev/null +++ b/.github/stale.yml @@ -0,0 +1,23 @@ +# Number of days of inactivity before an issue becomes stale +daysUntilStale: 28 +# Number of days of inactivity before a stale issue is closed +# Set to false to disable. If disabled, issues still need to be closed +# manually, but will remain marked as stale. +daysUntilClose: false +# Issues with these labels will never be considered stale +exemptLabels: + - v2 + - enhancement + - good first issue + - feature-request + - doc + - bug + - not-stale +# Label to use when marking an issue as stale +staleLabel: stale +# Comment to post when marking an issue as stale. Set to `false` to disable +markComment: > + This issue has been automatically marked as stale because it has not had + recent activity. Thank you for your contributions. +# Comment to post when closing a stale issue. Set to `false` to disable +closeComment: false diff --git a/.github/workflows/CI-docs.yml b/.github/workflows/CI-docs.yml deleted file mode 100644 index d112a98..0000000 --- a/.github/workflows/CI-docs.yml +++ /dev/null @@ -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@v3 - - uses: actions/setup-python@v4 - 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 diff --git a/.github/workflows/CI-unix.yml b/.github/workflows/CI-unix.yml index 993cfb7..506c00b 100644 --- a/.github/workflows/CI-unix.yml +++ b/.github/workflows/CI-unix.yml @@ -14,19 +14,6 @@ on: - master jobs: - build-linux: - runs-on: ubuntu-latest - steps: - - uses: actions/checkout@v3 - - name: configure - run: | - ./autogen.sh - mkdir build - (cd build && ../configure) - - name: distcheck - run: | - make -C build distcheck - build-android: runs-on: ubuntu-latest container: reactnativecommunity/react-native-android:2020-5-20 @@ -46,14 +33,14 @@ jobs: ls -lh build build-macos: - runs-on: macos-11 + runs-on: macos-10.15 steps: - uses: actions/checkout@v2 - name: Envinfo run: npx envinfo - name: Setup run: | - brew install ninja automake libtool + brew install ninja - name: Configure run: | mkdir build @@ -72,16 +59,9 @@ jobs: - name: Test 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: macos-11 + runs-on: macos-10.15 steps: - uses: actions/checkout@v2 - name: Configure @@ -114,6 +94,7 @@ jobs: - {target: mips64, toolchain: gcc-mips64-linux-gnuabi64, cc: mips64-linux-gnuabi64-gcc, qemu: qemu-mips64-static } - {target: mipsel, toolchain: gcc-mipsel-linux-gnu, cc: mipsel-linux-gnu-gcc, qemu: qemu-mipsel-static } - {target: mips64el,toolchain: gcc-mips64el-linux-gnuabi64, cc: mips64el-linux-gnuabi64-gcc,qemu: qemu-mips64el-static } + - {target: alpha, toolchain: gcc-alpha-linux-gnu, cc: alpha-linux-gnu-gcc, qemu: qemu-alpha-static } - {target: arm (u64 slots), toolchain: gcc-arm-linux-gnueabi, cc: arm-linux-gnueabi-gcc, qemu: qemu-arm-static} - {target: aarch64 (u64 slots), toolchain: gcc-aarch64-linux-gnu, cc: aarch64-linux-gnu-gcc, qemu: qemu-aarch64-static} - {target: ppc (u64 slots), toolchain: gcc-powerpc-linux-gnu, cc: powerpc-linux-gnu-gcc, qemu: qemu-ppc-static} @@ -125,7 +106,7 @@ jobs: # this ensure install latest qemu on ubuntu, apt get version is old env: QEMU_SRC: "http://archive.ubuntu.com/ubuntu/pool/universe/q/qemu" - QEMU_VER: "qemu-user-static_7\\.2+dfsg-.*_amd64.deb$" + QEMU_VER: "qemu-user-static_4\\.2-.*_amd64.deb$" run: | DEB=`curl -s $QEMU_SRC/ | grep -o -E 'href="([^"#]+)"' | cut -d'"' -f2 | grep $QEMU_VER | tail -1` wget $QEMU_SRC/$DEB diff --git a/.github/workflows/CI-win.yml b/.github/workflows/CI-win.yml index 79a5abf..9b9aa77 100644 --- a/.github/workflows/CI-win.yml +++ b/.github/workflows/CI-win.yml @@ -16,7 +16,7 @@ on: jobs: build-windows: runs-on: windows-${{ matrix.config.server }} - name: build-${{ join(matrix.config.*, '-') }} + name: build-${{ matrix.config.toolchain}}-${{ matrix.config.arch}} strategy: fail-fast: false matrix: @@ -25,106 +25,27 @@ jobs: - {toolchain: Visual Studio 16 2019, arch: x64, server: 2019} - {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} steps: - uses: actions/checkout@v2 + - name: Envinfo + run: npx envinfo - 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' || - matrix.config.config == 'UBSAN' && '-DUBSAN=on' || '' }} - - 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: + run: | + mkdir -p build cd build - - ctest -C RelWithDebInfo -V - - name: Test only static - if: ${{ matrix.config.config == 'ASAN' && matrix.config.arch != 'arm64' }} + cmake .. -DBUILD_TESTING=ON -G "${{ matrix.config.toolchain }}" -A ${{ matrix.config.arch }} + cmake --build . + - name: platform_output 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@v3 - - name: Install mingw32 environment - run: | - sudo apt update - sudo apt install mingw-w64 ninja-build -y - - name: Build run: | - cmake -S . -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@v3 - 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@v2 - with: - name: mingw-${{ matrix.config.arch }} - - name: Test + build\\Debug\\uv_run_tests.exe platform_output + - name: platform_output_a shell: cmd run: | - bin\uv_run_tests_a.exe + build\\Debug\\uv_run_tests_a.exe platform_output - name: Test shell: cmd run: | - bin\uv_run_tests.exe + cd build + ctest -C Debug -V diff --git a/.github/workflows/sanitizer.yml b/.github/workflows/sanitizer.yml index 4fca161..3c39117 100644 --- a/.github/workflows/sanitizer.yml +++ b/.github/workflows/sanitizer.yml @@ -13,8 +13,8 @@ on: - master jobs: - sanitizers-linux: - runs-on: ubuntu-22.04 + sanitizers: + runs-on: ubuntu-latest steps: - uses: actions/checkout@v2 - name: Setup @@ -22,102 +22,20 @@ jobs: sudo apt-get install ninja-build - name: Envinfo run: npx envinfo - - - name: ASAN Build - run: | - mkdir build-asan - (cd build-asan && cmake .. -G Ninja -DBUILD_TESTING=ON -DASAN=ON -DCMAKE_BUILD_TYPE=Debug) - cmake --build build-asan - - name: ASAN Test - run: | - ./build-asan/uv_run_tests_a - - - name: MSAN Build - run: | - mkdir build-msan - (cd build-msan && cmake .. -G Ninja -DBUILD_TESTING=ON -DMSAN=ON -DCMAKE_BUILD_TYPE=Debug -DCMAKE_C_COMPILER=clang) - cmake --build build-msan - - name: MSAN Test - run: | - ./build-msan/uv_run_tests_a - - name: TSAN Build run: | mkdir build-tsan (cd build-tsan && cmake .. -G Ninja -DBUILD_TESTING=ON -DTSAN=ON -DCMAKE_BUILD_TYPE=Release) cmake --build build-tsan - name: TSAN Test - # Note: path must be absolute because some tests chdir. - # TSan exits with an error when it can't find the file. - run: | - env TSAN_OPTIONS="suppressions=$PWD/tsansupp.txt" ./build-tsan/uv_run_tests_a - - - name: UBSAN Build + continue-on-error: true # currently permit failures run: | - mkdir build-ubsan - (cd build-ubsan && cmake .. -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 - - sanitizers-macos: - runs-on: macos-11 - steps: - - uses: actions/checkout@v2 - - - name: Envinfo - run: npx envinfo - + ./build-tsan/uv_run_tests_a - name: ASAN Build run: | mkdir build-asan - (cd build-asan && cmake .. -DBUILD_TESTING=ON -DASAN=ON -DCMAKE_BUILD_TYPE=Debug) + (cd build-asan && cmake .. -G Ninja -DBUILD_TESTING=ON -DASAN=ON -DCMAKE_BUILD_TYPE=Debug) cmake --build build-asan - name: ASAN Test run: | ./build-asan/uv_run_tests_a - - - name: TSAN Build - run: | - mkdir build-tsan - (cd build-tsan && cmake .. -DBUILD_TESTING=ON -DTSAN=ON -DCMAKE_BUILD_TYPE=Release) - cmake --build build-tsan - - name: TSAN Test - run: | - ./build-tsan/uv_run_tests_a - - - name: UBSAN Build - run: | - mkdir build-ubsan - (cd build-ubsan && cmake .. -DBUILD_TESTING=ON -DUBSAN=ON -DCMAKE_BUILD_TYPE=Debug) - cmake --build build-ubsan - - name: UBSAN Test - run: | - ./build-ubsan/uv_run_tests_a - - sanitizers-windows: - runs-on: windows-2022 - steps: - - uses: actions/checkout@v2 - - 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@v1 - with: - version: "17" - - - name: Envinfo - run: npx envinfo - - - name: UBSAN Build - run: | - mkdir build-ubsan - 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 diff --git a/.gitignore b/.gitignore index 6d396ef..7eb4932 100644 --- a/.gitignore +++ b/.gitignore @@ -7,11 +7,9 @@ *.sdf *.suo .vs/ -.vscode/ *.VC.db *.VC.opendb core -.cache vgcore.* .buildstamp .dirstamp @@ -76,5 +74,3 @@ cmake-build-debug/ # make dist output libuv-*.tar.* -/dist.libuv.org/ -/libuv-release-tool/ diff --git a/.mailmap b/.mailmap index bf12432..b23377c 100644 --- a/.mailmap +++ b/.mailmap @@ -29,7 +29,6 @@ Keno Fischer Keno Fischer Leith Bade Leonard Hecker -Lewis Russell Maciej Małecki Marc Schlaich Michael @@ -61,7 +60,5 @@ gengjiawen jBarz jBarz ptlomholt -theanarkh <2923878201@qq.com> tjarlama <59913901+tjarlama@users.noreply.github.com> -ywave620 <60539365+ywave620@users.noreply.github.com> zlargon diff --git a/.readthedocs.yaml b/.readthedocs.yaml index b16bf0d..e53b9f3 100644 --- a/.readthedocs.yaml +++ b/.readthedocs.yaml @@ -5,11 +5,7 @@ sphinx: configuration: null fail_on_warning: false -build: - os: "ubuntu-22.04" - tools: - python: "3.9" - python: + version: 3.8 install: - requirements: docs/requirements.txt diff --git a/AUTHORS b/AUTHORS index f3942ce..e03100e 100644 --- a/AUTHORS +++ b/AUTHORS @@ -517,53 +517,3 @@ chucksilvers Sergey Fedorov theanarkh <2923878201@qq.com> Samuel Cabrero -自发对称破缺 <429839446@qq.com> -Luan Devecchi -Steven Schveighoffer -number201724 -Daniel -Christian Clason -ywave620 -jensbjorgensen -daomingq -Qix -Edward Humes <29870961+aurxenon@users.noreply.github.com> -Tim Besard -Sergey Rubanov -Stefan Stojanovic -Zvicii -dundargoc <33953936+dundargoc@users.noreply.github.com> -Jack·Boos·Yu <47264268+JackBoosY@users.noreply.github.com> -panran <310762957@qq.com> -Tamás Bálint Misius -Bruno Passeri -Jason Zhang -Lewis Russell -sivadeilra -cui fliter -Mohammed Keyvanzadeh -Niklas Mischkulnig <4586894+mischnic@users.noreply.github.com> -Stefan Karpinski -liuxiang88 <94350585+liuxiang88@users.noreply.github.com> -Jeffrey H. Johnson -Abdirahim Musse <33973272+abmusse@users.noreply.github.com> -小明 <7737673+caobug@users.noreply.github.com> -Shuduo Sang -Keith Winstein -michalbiesek -Alois Klink -SmorkalovG -Pleuvens -jolai <58589285+laijonathan@users.noreply.github.com> -Julien Roncaglia -prubel -Per Allansson <65364157+per-allansson@users.noreply.github.com> -Matheus Izvekov -Christian Heimlich -Hao Hu <33607772+hhu8@users.noreply.github.com> -matoro <12038583+matoro@users.noreply.github.com> -Bo Anderson -Ardi Nugraha <33378542+ardi-nugraha@users.noreply.github.com> -Anton Bachin -Trevor Flynn -Andy Pan diff --git a/BUILD.gn b/BUILD.gn index 5be0738..d21817b 100644 --- a/BUILD.gn +++ b/BUILD.gn @@ -74,7 +74,6 @@ if (defined(ohos_lite)) { "src/random.c", "src/strscpy.c", "src/strtok.c", - "src/thread-common.c", "src/threadpool.c", "src/timer.c", "src/uv-common.c", @@ -85,10 +84,10 @@ if (defined(ohos_lite)) { "src/unix/async.c", "src/unix/core.c", "src/unix/dl.c", + "src/unix/epoll.c", "src/unix/fs.c", "src/unix/getaddrinfo.c", "src/unix/getnameinfo.c", - "src/unix/linux.c", "src/unix/loop-watcher.c", "src/unix/loop.c", "src/unix/no-fsevents.c", @@ -131,7 +130,6 @@ if (defined(ohos_lite)) { "src/random.c", "src/strscpy.c", "src/threadpool.c", - "src/thread-common.c", "src/timer.c", "src/uv-common.c", "src/uv-data-getter-setters.c", @@ -140,6 +138,7 @@ if (defined(ohos_lite)) { ] if (!is_mingw && !is_win) { nonwin_srcs = [ + "src/unix/epoll.c", "src/unix/async.c", "src/unix/core.c", "src/unix/dl.c", @@ -210,7 +209,6 @@ if (defined(ohos_lite)) { defines = [ "WIN32_LEAN_AND_MEAN", "_WIN32_WINNT=0x0600", - "_CRT_DECLARE_NONSTDC_NAMES=0", ] libs = [ @@ -220,9 +218,6 @@ if (defined(ohos_lite)) { "iphlpapi", "userenv", "ws2_32", - "dbghelp", - "ole32", - "shell32", ] } } @@ -254,6 +249,7 @@ if (defined(ohos_lite)) { "src/unix/log_unix.c", "src/unix/trace_unix.c", ] + sources -= [ "src/unix/epoll.c" ] } else if (is_mingw || is_win) { sources += [ "src/win/async.c", @@ -286,8 +282,11 @@ if (defined(ohos_lite)) { ] } else if (is_ohos || (defined(is_android) && is_android)) { sources += nonwin_srcs + [ - "src/unix/linux.c", + "src/unix/linux-core.c", + "src/unix/linux-inotify.c", + "src/unix/linux-syscalls.c", "src/unix/procfs-exepath.c", + "src/unix/pthread-fixes.c", "src/unix/random-getentropy.c", "src/unix/random-getrandom.c", "src/unix/random-sysctl-linux.c", @@ -314,7 +313,9 @@ if (defined(ohos_lite)) { } } else if (is_linux) { sources += nonwin_srcs + [ - "src/unix/linux.c", + "src/unix/linux-core.c", + "src/unix/linux-inotify.c", + "src/unix/linux-syscalls.c", "src/unix/procfs-exepath.c", "src/unix/random-getrandom.c", "src/unix/random-sysctl-linux.c", @@ -324,7 +325,9 @@ if (defined(ohos_lite)) { ] } else { sources += nonwin_srcs + [ - "src/unix/linux.c", + "src/unix/linux-core.c", + "src/unix/linux-inotify.c", + "src/unix/linux-syscalls.c", "src/unix/procfs-exepath.c", "src/unix/random-getrandom.c", "src/unix/random-sysctl-linux.c", diff --git a/CMakeLists.txt b/CMakeLists.txt index 5e8e016..7f46682 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,14 +1,9 @@ -cmake_minimum_required(VERSION 3.9) - -if(POLICY CMP0091) - cmake_policy(SET CMP0091 NEW) # Enable MSVC_RUNTIME_LIBRARY setting -endif() -if(POLICY CMP0092) - cmake_policy(SET CMP0092 NEW) # disable /W3 warning, if possible -endif() - +cmake_minimum_required(VERSION 3.4) project(libuv LANGUAGES C) +cmake_policy(SET CMP0057 NEW) # Enable IN_LIST operator +cmake_policy(SET CMP0064 NEW) # Support if (TEST) operator + list(APPEND CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/cmake") include(CMakePackageConfigHelpers) @@ -22,13 +17,9 @@ set(CMAKE_C_STANDARD_REQUIRED ON) set(CMAKE_C_EXTENSIONS ON) set(CMAKE_C_STANDARD 90) -set(CMAKE_EXPORT_COMPILE_COMMANDS ON) - -option(LIBUV_BUILD_SHARED "Build shared lib" ON) - cmake_dependent_option(LIBUV_BUILD_TESTS "Build the unit tests when BUILD_TESTING is enabled and we are the root project" ON - "BUILD_TESTING;LIBUV_BUILD_SHARED;CMAKE_SOURCE_DIR STREQUAL PROJECT_SOURCE_DIR" OFF) + "BUILD_TESTING;CMAKE_SOURCE_DIR STREQUAL PROJECT_SOURCE_DIR" OFF) cmake_dependent_option(LIBUV_BUILD_BENCH "Build the benchmarks when building unit tests and we are the root project" ON "LIBUV_BUILD_TESTS" OFF) @@ -36,61 +27,28 @@ cmake_dependent_option(LIBUV_BUILD_BENCH # Qemu Build option(QEMU "build for qemu" OFF) if(QEMU) - list(APPEND uv_defines __QEMU__=1) + add_definitions(-D__QEMU__=1) endif() -# Note: these are mutually exclusive. option(ASAN "Enable AddressSanitizer (ASan)" OFF) -option(MSAN "Enable MemorySanitizer (MSan)" OFF) option(TSAN "Enable ThreadSanitizer (TSan)" OFF) -option(UBSAN "Enable UndefinedBehaviorSanitizer (UBSan)" OFF) -if(MSAN AND NOT CMAKE_C_COMPILER_ID MATCHES "AppleClang|Clang") - message(SEND_ERROR "MemorySanitizer requires clang. Try again with -DCMAKE_C_COMPILER=clang") +if((ASAN OR TSAN) AND NOT (CMAKE_C_COMPILER_ID MATCHES "AppleClang|GNU|Clang")) + message(SEND_ERROR "Sanitizer support requires clang or gcc. Try again with -DCMAKE_C_COMPILER.") endif() if(ASAN) - list(APPEND uv_defines __ASAN__=1) - if(CMAKE_C_COMPILER_ID MATCHES "AppleClang|GNU|Clang") - set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fno-omit-frame-pointer -fsanitize=address") - set (CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -fno-omit-frame-pointer -fsanitize=address") - set (CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fno-omit-frame-pointer -fsanitize=address") - elseif(MSVC) - set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /fsanitize=address") - else() - message(SEND_ERROR "AddressSanitizer support requires clang, gcc, or msvc. Try again with -DCMAKE_C_COMPILER.") - endif() -endif() - -if(MSAN) - list(APPEND uv_defines __MSAN__=1) - set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fno-omit-frame-pointer -fsanitize=memory") - set (CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -fno-omit-frame-pointer -fsanitize=memory") - set (CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fno-omit-frame-pointer -fsanitize=memory") + add_definitions(-D__ASAN__=1) + set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fno-omit-frame-pointer -fsanitize=address") + set (CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -fno-omit-frame-pointer -fsanitize=address") + set (CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fno-omit-frame-pointer -fsanitize=address") endif() if(TSAN) - list(APPEND uv_defines __TSAN__=1) - if(CMAKE_C_COMPILER_ID MATCHES "AppleClang|GNU|Clang") - set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fno-omit-frame-pointer -fsanitize=thread") - set (CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -fno-omit-frame-pointer -fsanitize=thread") - set (CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fno-omit-frame-pointer -fsanitize=thread") - else() - message(SEND_ERROR "ThreadSanitizer support requires clang or gcc. Try again with -DCMAKE_C_COMPILER.") - endif() -endif() - -if(UBSAN) - list(APPEND uv_defines __UBSAN__=1) - if(CMAKE_C_COMPILER_ID MATCHES "AppleClang|GNU|Clang") - set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fno-omit-frame-pointer -fsanitize=undefined") - set (CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -fno-omit-frame-pointer -fsanitize=undefined") - set (CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fno-omit-frame-pointer -fsanitize=undefined") - elseif(MSVC) - set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /fsanitize=undefined") - else() - message(SEND_ERROR "UndefinedBehaviorSanitizer support requires clang, gcc, or msvc. Try again with -DCMAKE_C_COMPILER.") - endif() + add_definitions(-D__TSAN__=1) + set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fno-omit-frame-pointer -fsanitize=thread") + set (CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -fno-omit-frame-pointer -fsanitize=thread") + set (CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fno-omit-frame-pointer -fsanitize=thread") endif() # Compiler check @@ -161,11 +119,6 @@ list(APPEND uv_cflags ${lint-utf8-msvc} ) check_c_compiler_flag(-fno-strict-aliasing UV_F_STRICT_ALIASING) list(APPEND uv_cflags $<$:-fno-strict-aliasing>) -if (MSVC) - # Error on calling undeclared functions. - list(APPEND uv_cflags "/we4013") -endif() - set(uv_sources src/fs-poll.c src/idna.c @@ -173,7 +126,6 @@ set(uv_sources src/random.c src/strscpy.c src/strtok.c - src/thread-common.c src/threadpool.c src/timer.c src/uv-common.c @@ -181,17 +133,14 @@ set(uv_sources src/version.c) if(WIN32) - list(APPEND uv_defines WIN32_LEAN_AND_MEAN _WIN32_WINNT=0x0602 _CRT_DECLARE_NONSTDC_NAMES=0) + list(APPEND uv_defines WIN32_LEAN_AND_MEAN _WIN32_WINNT=0x0602) list(APPEND uv_libraries psapi user32 advapi32 iphlpapi userenv - ws2_32 - dbghelp - ole32 - shell32) + ws2_32) list(APPEND uv_sources src/win/async.c src/win/core.c @@ -267,11 +216,15 @@ if(CMAKE_SYSTEM_NAME STREQUAL "Android") list(APPEND uv_defines _GNU_SOURCE) list(APPEND uv_libraries dl) list(APPEND uv_sources - src/unix/linux.c + src/unix/linux-core.c + src/unix/linux-inotify.c + src/unix/linux-syscalls.c src/unix/procfs-exepath.c + src/unix/pthread-fixes.c src/unix/random-getentropy.c src/unix/random-getrandom.c - src/unix/random-sysctl-linux.c) + src/unix/random-sysctl-linux.c + src/unix/epoll.c) endif() if(APPLE OR CMAKE_SYSTEM_NAME MATCHES "Android|Linux") @@ -317,14 +270,22 @@ if(CMAKE_SYSTEM_NAME STREQUAL "GNU") src/unix/hurd.c) endif() +if(CMAKE_SYSTEM_NAME STREQUAL "kFreeBSD") + list(APPEND uv_defines _GNU_SOURCE) + list(APPEND uv_libraries dl freebsd-glue) +endif() + if(CMAKE_SYSTEM_NAME STREQUAL "Linux") list(APPEND uv_defines _GNU_SOURCE _POSIX_C_SOURCE=200112) list(APPEND uv_libraries dl rt) list(APPEND uv_sources - src/unix/linux.c + src/unix/linux-core.c + src/unix/linux-inotify.c + src/unix/linux-syscalls.c src/unix/procfs-exepath.c src/unix/random-getrandom.c - src/unix/random-sysctl-linux.c) + src/unix/random-sysctl-linux.c + src/unix/epoll.c) endif() if(CMAKE_SYSTEM_NAME STREQUAL "NetBSD") @@ -355,6 +316,7 @@ if(CMAKE_SYSTEM_NAME STREQUAL "OS390") list(APPEND uv_defines _XOPEN_SOURCE=600) list(APPEND uv_defines _XOPEN_SOURCE_EXTENDED) list(APPEND uv_sources + src/unix/pthread-fixes.c src/unix/os390.c src/unix/os390-syscalls.c src/unix/os390-proctitle.c) @@ -392,10 +354,6 @@ if(CMAKE_SYSTEM_NAME STREQUAL "OS400") endif() if(CMAKE_SYSTEM_NAME STREQUAL "SunOS") - if(CMAKE_SYSTEM_VERSION STREQUAL "5.10") - list(APPEND uv_defines SUNOS_NO_IFADDRS) - list(APPEND uv_libraries rt) - endif() list(APPEND uv_defines __EXTENSIONS__ _XOPEN_SOURCE=500 _REENTRANT) list(APPEND uv_libraries kstat nsl sendfile socket) list(APPEND uv_sources @@ -430,42 +388,25 @@ if(APPLE OR CMAKE_SYSTEM_NAME MATCHES "DragonFly|FreeBSD|Linux|NetBSD|OpenBSD") list(APPEND uv_test_libraries util) endif() -if(CYGWIN OR MSYS) - list(APPEND uv_defines _GNU_SOURCE) - list(APPEND uv_sources - src/unix/cygwin.c - src/unix/bsd-ifaddrs.c - src/unix/no-fsevents.c - src/unix/no-proctitle.c - src/unix/posix-hrtime.c - src/unix/posix-poll.c - src/unix/procfs-exepath.c - src/unix/sysinfo-loadavg.c - src/unix/sysinfo-memory.c) -endif() - -if(LIBUV_BUILD_SHARED) - add_library(uv SHARED ${uv_sources}) - target_compile_definitions(uv - INTERFACE - USING_UV_SHARED=1 - PRIVATE - BUILDING_UV_SHARED=1 - ${uv_defines}) - target_compile_options(uv PRIVATE ${uv_cflags}) - target_include_directories(uv - PUBLIC - $ - $ - PRIVATE - $) - if(CMAKE_SYSTEM_NAME STREQUAL "OS390") - target_include_directories(uv PUBLIC $) - set_target_properties(uv PROPERTIES LINKER_LANGUAGE CXX) - endif() - target_link_libraries(uv ${uv_libraries}) - set_target_properties(uv PROPERTIES OUTPUT_NAME "uv") +add_library(uv SHARED ${uv_sources}) +target_compile_definitions(uv + INTERFACE + USING_UV_SHARED=1 + PRIVATE + BUILDING_UV_SHARED=1 + ${uv_defines}) +target_compile_options(uv PRIVATE ${uv_cflags}) +target_include_directories(uv + PUBLIC + $ + $ + PRIVATE + $) +if(CMAKE_SYSTEM_NAME STREQUAL "OS390") + target_include_directories(uv PUBLIC $) + set_target_properties(uv PROPERTIES LINKER_LANGUAGE CXX) endif() +target_link_libraries(uv ${uv_libraries}) add_library(uv_a STATIC ${uv_sources}) target_compile_definitions(uv_a PRIVATE ${uv_defines}) @@ -481,10 +422,6 @@ if(CMAKE_SYSTEM_NAME STREQUAL "OS390") set_target_properties(uv_a PROPERTIES LINKER_LANGUAGE CXX) endif() target_link_libraries(uv_a ${uv_libraries}) -set_target_properties(uv_a PROPERTIES OUTPUT_NAME "uv") -if(WIN32) - set_target_properties(uv_a PROPERTIES PREFIX "lib") -endif() if(LIBUV_BUILD_TESTS) # Small hack: use ${uv_test_sources} now to get the runner skeleton, @@ -647,7 +584,6 @@ if(LIBUV_BUILD_TESTS) test/test-tcp-rst.c test/test-tcp-shutdown-after-write.c test/test-tcp-try-write.c - test/test-tcp-write-in-a-row.c test/test-tcp-try-write-error.c test/test-tcp-unexpected-read.c test/test-tcp-write-after-connect.c @@ -656,10 +592,8 @@ if(LIBUV_BUILD_TESTS) test/test-tcp-write-to-half-open-connection.c test/test-tcp-writealot.c test/test-test-macros.c - test/test-thread-affinity.c test/test-thread-equal.c test/test-thread.c - test/test-thread-priority.c test/test-threadpool-cancel.c test/test-threadpool.c test/test-timer-again.c @@ -690,7 +624,6 @@ if(LIBUV_BUILD_TESTS) test/test-udp-sendmmsg-error.c test/test-udp-send-unreachable.c test/test-udp-try-send.c - test/test-udp-recv-in-a-row.c test/test-uname.c test/test-walk-handles.c test/test-watcher-cross-stop.c) @@ -707,12 +640,6 @@ if(LIBUV_BUILD_TESTS) set_tests_properties(uv_test PROPERTIES ENVIRONMENT "LIBPATH=${CMAKE_BINARY_DIR}:$ENV{LIBPATH}") endif() - if(WIN32) - add_custom_command(TARGET uv_run_tests POST_BUILD - COMMAND "${CMAKE_COMMAND}" -E copy - "$" - "$/uv_run_tests_no_ext") - endif() 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}) @@ -729,12 +656,6 @@ if(LIBUV_BUILD_TESTS) set_target_properties(uv_run_tests PROPERTIES LINKER_LANGUAGE CXX) set_target_properties(uv_run_tests_a PROPERTIES LINKER_LANGUAGE CXX) endif() - if(WIN32) - add_custom_command(TARGET uv_run_tests_a POST_BUILD - COMMAND "${CMAKE_COMMAND}" -E copy - "$" - "$/uv_run_tests_a_no_ext") - endif() endif() # Now for some gibbering horrors from beyond the stars... @@ -746,45 +667,30 @@ string(REPLACE ";" " " LIBS "${LIBS}") file(STRINGS configure.ac configure_ac REGEX ^AC_INIT) string(REGEX MATCH "([0-9]+)[.][0-9]+[.][0-9]+" PACKAGE_VERSION "${configure_ac}") set(UV_VERSION_MAJOR "${CMAKE_MATCH_1}") - +# The version in the filename is mirroring the behaviour of autotools. +set_target_properties(uv PROPERTIES + VERSION ${UV_VERSION_MAJOR}.0.0 + SOVERSION ${UV_VERSION_MAJOR}) set(includedir ${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_INCLUDEDIR}) set(libdir ${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}) set(prefix ${CMAKE_INSTALL_PREFIX}) +configure_file(libuv.pc.in libuv.pc @ONLY) configure_file(libuv-static.pc.in libuv-static.pc @ONLY) install(DIRECTORY include/ DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}) install(FILES LICENSE DESTINATION ${CMAKE_INSTALL_DOCDIR}) -install(FILES LICENSE-extra DESTINATION ${CMAKE_INSTALL_DOCDIR}) -install(FILES ${PROJECT_BINARY_DIR}/libuv-static.pc +install(FILES ${PROJECT_BINARY_DIR}/libuv.pc ${PROJECT_BINARY_DIR}/libuv-static.pc DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig) +install(TARGETS uv EXPORT libuvConfig + RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} + LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} + ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}) install(TARGETS uv_a EXPORT libuvConfig ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}) -install(EXPORT libuvConfig - DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/libuv - NAMESPACE libuv::) - -if(LIBUV_BUILD_SHARED) - # The version in the filename is mirroring the behaviour of autotools. - set_target_properties(uv PROPERTIES - VERSION ${UV_VERSION_MAJOR}.0.0 - SOVERSION ${UV_VERSION_MAJOR}) - configure_file(libuv.pc.in libuv.pc @ONLY) - install(FILES ${PROJECT_BINARY_DIR}/libuv.pc - DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig) - install(TARGETS uv EXPORT libuvConfig - RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} - LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} - ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}) -endif() +install(EXPORT libuvConfig DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/libuv) if(MSVC) set(CMAKE_DEBUG_POSTFIX d) - get_filename_component(CMAKE_C_COMPILER_DIR ${CMAKE_C_COMPILER} DIRECTORY) - if(ASAN) - file(INSTALL "${CMAKE_C_COMPILER_DIR}/llvm-symbolizer.exe" DESTINATION "${CMAKE_CURRENT_BINARY_DIR}") - file(INSTALL "${CMAKE_C_COMPILER_DIR}/clang_rt.asan_dynamic-x86_64.dll" DESTINATION "${CMAKE_CURRENT_BINARY_DIR}") - file(INSTALL "${CMAKE_C_COMPILER_DIR}/clang_rt.asan_dbg_dynamic-x86_64.dll" DESTINATION "${CMAKE_CURRENT_BINARY_DIR}") - endif() endif() message(STATUS "summary of build options: diff --git a/ChangeLog b/ChangeLog index a98c21e..cfbfed4 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,557 +1,4 @@ -2024.02.07, Version 1.48.0 (Stable) - -Changes since version 1.47.0: - -* misc: remove deprecated stalebot file (Jameson Nash) - -* build: disable windows asan buildbot (Ben Noordhuis) - -* test: don't run tcp_writealot under msan (Ben Noordhuis) - -* build,win: remove extraneous -lshell32 (Ben Noordhuis) - -* unix: ignore ifaddrs with NULL ifa_addr (Stephen Gallagher) - -* unix,win: utility for setting priority for thread (Hao Hu) - -* pipe: add back error handling to connect / bind (Jameson Nash) - -* test: check if ipv6 link-local traffic is routable (Ben Noordhuis) - -* win: remove check for UV_PIPE_NO_TRUNCATE (Jameson Nash) - -* linux: disable io_uring on hppa below kernel 6.1.51 (matoro) - -* unix,win: fix read past end of pipe name buffer (Ben Noordhuis) - -* unix: unbreak macOS < 10.14 (Sergey Fedorov) - -* aix: disable ipv6 link local (Abdirahim Musse) - -* doc: move cjihrig to emeriti (cjihrig) - -* unix: correct pwritev conditional (Bo Anderson) - -* test_fs.c: Fix issue on 32-bit systems using btrfs (Stephen Gallagher) - -* misc: ignore libuv-release-tool files (Jameson Nash) - -* win: honor NoDefaultCurrentDirectoryInExePath env var (Ardi Nugraha) - -* idna: fix compilation warning (Saúl Ibarra Corretgé) - -* linux: remove HAVE_IFADDRS_H macro (Ben Noordhuis) - -* test: skip tcp-write-in-a-row on IBM i (Abdirahim Musse) - -* build,win: work around missing uuid.dll on MinGW (Anton Bachin) - -* win: stop using deprecated names (Matheus Izvekov) - -* unix,win: fix busy loop with zero timeout timers (Matheus Izvekov) - -* aix,ibmi: use uv_interface_addresses instead of getifaddrs (Abdirahim Musse) - -* linux: fix bind/connect for abstract sockets (Santiago Gimeno) - -* win: replace c99 comments with c89 comments (Trevor Flynn) - -* build: add .cache clangd folder to .gitignore (Juan José Arboleda) - -* unix: support full TCP keep-alive on Solaris (Andy Pan) - -* freebsd: fix F_KINFO file path handling (David Carlier) - -* linux: retry fs op if unsupported by io_uring (Santiago Gimeno) - -* freebsd: fix build on non-intel archs (David Carlier) - -* unix: optimize uv__tcp_keepalive cpp directives (Andy Pan) - -* linux: disable io_uring on ppc64 and ppc64le (Brad King) - -* doc: add very basic Security Policy document (Santiago Gimeno) - -* build: re-enable msvc-asan job on CI (Jameson Nash) - -* win/spawn: optionally run executable paths with no file extension (Brad King) - -* win: fix ESRCH implementation (Jameson Nash) - -* unix,win: reset the timer queue on stop (Santiago Gimeno) - -* fix: always zero-terminate idna output (Ben Noordhuis) - -* fix: reject zero-length idna inputs (Ben Noordhuis) - -* test: empty strings are not valid IDNA (Santiago Gimeno) - -* Merge pull request from GHSA-f74f-cvh7-c6q6 (Ben Noordhuis) - -* --------------------------------------------------------------------------------------- - -2023.11.06, Version 1.47.0 (Stable), be6b81a352d17513c95be153afcb3148f1a451cd - -Changes since version 1.46.0: - -* test: fix license blurb (Ben Noordhuis) - -* linux: fix harmless warn_unused_result warning (Shuduo Sang) - -* darwin: fix build warnings (小明) - -* linux: don't use io_uring on pre-5.10.186 kernels (Ben Noordhuis) - -* fs: fix WTF-8 decoding issue (Jameson Nash) - -* test: enable disabled tcp_connect6_error_fault (Ben Noordhuis) - -* test: enable disabled fs_link (Ben Noordhuis) - -* test: enable disabled spawn_same_stdout_stderr (Ben Noordhuis) - -* linux: handle UNAME26 personality (Ben Noordhuis) - -* build: move cmake_minimum_required version to 3.9 (Keith Winstein) - -* unix: set ipv6 scope id for link-local addresses (Ben Noordhuis) - -* unix: match kqueue and epoll code (Trevor Norris) - -* win,spawn: allow `%PATH%` to be unset (Kyle Edwards) - -* doc: switch to Furo, a more modern Sphinx theme (Saúl Ibarra Corretgé) - -* darwin: make TCP_KEEPINTVL and TCP_KEEPCNT available (小明) - -* win,fs: avoid winapi macro redefinition (Brad King) - -* linux: add missing riscv syscall numbers (michalbiesek) - -* doc: fix broken "Shared library" Wikipedia link (Alois Klink) - -* unix: get mainline kernel version in Ubuntu (Santiago Gimeno) - -* unix: get mainline kernel version in Debian (Ben Noordhuis) - -* build: fix qemu install in CI-unix workflow (Santiago Gimeno) - -* unix: disable io_uring close on selected kernels (Santiago Gimeno) - -* test: skip tests when ipv6 is not available (Santiago Gimeno) - -* ibmi: implement ifaddrs, getifaddrs, freeifaddrs (Abdirahim Musse) - -* unix: reset signal counters after fork (SmorkalovG) - -* win,process: avoid assert after spawning Store app (Jameson Nash) - -* unix: remove pread/preadv conditionals (Ben Noordhuis) - -* unix: remove pwrite/pwritev conditionals (Ben Noordhuis) - -* darwin: remove workaround for data corruption bug (Ben Noordhuis) - -* src: default to stream=stderr in handle printer (Ben Noordhuis) - -* test: switch to new-style ASSERT_EQ macros (Pleuvens) - -* zos: correctly get cpu model in uv_cpu_info() (jolai) - -* test: fix get_passwd2 on IBM i (Abdirahim Musse) - -* unix: don't malloc on sync uv_fs_read (Ben Noordhuis) - -* freebsd: get fs event path with fcntl(F_KINFO) (David Carlier) - -* test: switch from ASSERT_* to ASSERT_PTR_* (Pleuvens) - -* darwin: workaround apple pthread_cond_wait bug (Julien Roncaglia) - -* doc: uv_close should be called after exit callback (Pleuvens) - -* test: 192.0.2.0/24 is the actual -TEST-NET-1 (prubel) - -* unix: add back preadv/pwritev fallback (Ben Noordhuis) - -* unix: rename variable for consistency (Ben Noordhuis) - -* unix: merge read/write code into single functions (Ben Noordhuis) - -* doc: filename arg to uv_fs_event_cb can be NULL (Ben Noordhuis) - -* build,win: we need to link against shell32.lib (Per Allansson) - -* unix: no preadv/pwritev workaround if not needed (Jeffrey H. Johnson) - -* build: add CI for Windows ARM64 (build only) (Per Allansson) - -* linux: disable io_uring on 32 bits arm systems (Ben Noordhuis) - -* build: run sanitizers on macos ci (Ben Noordhuis) - -* misc: export WTF8 conversion utilities (Jameson Nash) - -* build: fix libuv.a file name for cmake (Jameson Nash) - -* build: add windows ubsan and clang ci (Matheus Izvekov) - -* win: improve accuracy of ProductName between arch (Christian Heimlich) - - -2023.06.30, Version 1.46.0 (Stable), f0bb7e40f0508bedf6fad33769b3f87bb8aedfa6 - -Changes since version 1.45.0: - -* Add SHA to ChangeLog (Santiago Gimeno) - -* misc: update readthedocs config (Jameson Nash) - -* test: remove erroneous RETURN_SKIP (Ben Noordhuis) - -* android: disable io_uring support (Ben Noordhuis) - -* linux: add some more iouring backed fs ops (Santiago Gimeno) - -* build: add autoconf option for disable-maintainer-mode (Jameson Nash) - -* fs: use WTF-8 on Windows (Stefan Karpinski) - -* unix,win: replace QUEUE with struct uv__queue (Ben Noordhuis) - -* linux: fs_read to use io_uring if iovcnt > IOV_MAX (Santiago Gimeno) - -* ios: fix uv_getrusage() ru_maxrss calculation (Ben Noordhuis) - -* include: update outdated code comment (Ben Noordhuis) - -* linux: support abstract unix sockets (Ben Noordhuis) - -* unix,win: add UV_PIPE_NO_TRUNCATE flag (Ben Noordhuis) - -* unix: add loongarch support (liuxiang88) - -* doc: add DPS8M to LINKS.md (Jeffrey H. Johnson) - -* include: add EUNATCH errno mapping (Abdirahim Musse) - -* src: don't run timers if loop is stopped/unref'd (Trevor Norris) - -* win: fix -Wpointer-to-int-cast warning (Ben Noordhuis) - -* test,win: fix -Wunused-variable warning (Ben Noordhuis) - -* test,win: fix -Wformat warning (Ben Noordhuis) - -* linux: work around io_uring IORING_OP_CLOSE bug (Ben Noordhuis) - -* win: remove unused functions (Ben Noordhuis) - -* bench: add bench to check uv_loop_alive (Trevor Norris) - -* test: add uv_cancel test for threadpool (Trevor Norris) - -* unix: skip prohibited syscalls on tvOS and watchOS (小明) - -* unix,fs: make no_pwritev access thread-safe (Santiago Gimeno) - -* unix: fix build for lower versions of Android (小明) - - -2023.05.19, Version 1.45.0 (Stable), 96e05543f53b19d9642b4b0dd73b86ad3cea313e - -Changes since version 1.44.2: - -* win: remove stdint-msvc2008.h (Ben Noordhuis) - -* android: remove pthread-fixes.c (Ben Noordhuis) - -* build: enable MSVC_RUNTIME_LIBRARY setting (自发对称破缺) - -* unix: switch to c11 atomics (Ben Noordhuis) - -* unix: don't accept() connections in a loop (Ben Noordhuis) - -* win: fix off-by-1 buffer overrun in uv_exepath() (Ben Noordhuis) - -* build: switch ci from macos-10.15 to macos-11 (Ben Noordhuis) - -* win: fix thread race in uv_cwd() and uv_chdir() (Ben Noordhuis) - -* unix,win: remove UV_HANDLE_SHUTTING flag (Santiago Gimeno) - -* win: support Windows 11 in uv_os_uname() (Luan Devecchi) - -* unix: fix uv_getrusage() ru_maxrss reporting (Ben Noordhuis) - -* doc: add note about offset -1 in uv_fs_read/write (Steven Schveighoffer) - -* test: fix musl libc.a dlerror() test expectation (Ben Noordhuis) - -* kqueue: DRY file descriptor deletion logic (Ben Noordhuis) - -* linux: teach uv_get_constrained_memory() cgroupsv2 (Ben Noordhuis) - -* build: upgrade qemu-user-static package (Ben Noordhuis) - -* linux: move epoll.c back into linux-core.c (Ben Noordhuis) - -* unix: remove pre-macos 10.8 compatibility hack (Ben Noordhuis) - -* unix,win: fix memory leak in uv_fs_scandir() (Ben Noordhuis) - -* build: restore qemu download logic (Ben Noordhuis) - -* win: fix uv__pipe_accept memory leak (number201724) - -* doc: update LINKS.md (Daniel) - -* unix: simplify atomic op in uv_tty_reset_mode() (Ben Noordhuis) - -* build: add LIBUV_BUILD_SHARED cmake option (Christian Clason) - -* linux: remove unused or obsolete syscall wrappers (Ben Noordhuis) - -* linux: merge files back into single file (Ben Noordhuis) - -* stream: process more than one write req per loop tick (ywave620) - -* unix,win: give thread pool threads an 8 MB stack (Ben Noordhuis) - -* build: add MemorySanitizer (MSAN) support (Ben Noordhuis) - -* doc: add uv_poll_cb status==UV_EBADF note (jensbjorgensen) - -* build: support AddressSanitizer on MSVC (Jameson Nash) - -* win,pipe: improve method of obtaining pid for ipc (number201724) - -* thread: add support for affinity (daomingq) - -* include: map ENODATA error code (Ben Noordhuis) - -* build: remove bashism from autogen.sh (Santiago Gimeno) - -* win,tcp,udp: remove "active streams" optimization (Saúl Ibarra Corretgé) - -* win: drop code checking for Windows XP / Server 2k3 (Saúl Ibarra Corretgé) - -* unix,win: fix 'sprintf' is deprecated warning (twosee) - -* doc: mention close_cb can be NULL (Qix) - -* win: optimize udp receive performance (ywave620) - -* win: fix an incompatible types warning (twosee) - -* doc: document 0 return value for free/total memory (Ben Noordhuis) - -* darwin: use hw.cpufrequency again for frequency info (Jameson Nash) - -* win,test: change format of TEST_PIPENAME's (Santiago Gimeno) - -* win,pipe: fixes in uv_pipe_connect() (Santiago Gimeno) - -* misc: fix return value of memory functions (theanarkh) - -* src: add new metrics APIs (Trevor Norris) - -* thread: add uv_thread_getcpu() (daomingq) - -* build: don't use ifaddrs.h on solaris 10 (Edward Humes) - -* unix,win: add uv_get_available_memory() (Tim Besard) - -* test: fix -Wunused-but-set-variable warnings (Ben Noordhuis) - -* doc: bump min supported linux and freebsd versions (Ben Noordhuis) - -* Add Socket Runtime to the LINKS.md (Sergey Rubanov) - -* unix: drop kfreebsd support (Ben Noordhuis) - -* win: fix fstat for pipes and character files (Stefan Stojanovic) - -* win: fix -Wunused-variable warning (Ben Noordhuis) - -* win: fix -Wunused-function warning (Ben Noordhuis) - -* build: drop qemu-alpha from ci matrix (Ben Noordhuis) - -* win: move child_stdio_buffer out of uv_process_t (Santiago Gimeno) - -* test: fix some unreachable code warnings (Santiago Gimeno) - -* linux: simplify uv_uptime() (Ben Noordhuis) - -* test: unflake fs_event_watch_dir test (Ben Noordhuis) - -* darwin: remove unused fsevents symbol lookups (Ben Noordhuis) - -* build: add define guard around UV_EXTERN (Zvicii) - -* build: add UndefinedBehaviorSanitizer support (Ben Noordhuis) - -* build: enable platform_output test on qemu (Ben Noordhuis) - -* linux: handle cpu hotplugging in uv_cpu_info() (Ben Noordhuis) - -* build: remove unnecessary policy setting (dundargoc) - -* docs: add vcpkg instruction step (Jack·Boos·Yu) - -* win,fs: fix readlink errno for a non-symlink file (Darshan Sen) - -* misc: extend getpw to take uid as an argument (Jameson Nash) - -* unix,win: use static_assert when available (Ben Noordhuis) - -* docs: delete code Makefile (Jameson Nash) - -* docs: add CI for docs PRs (Jameson Nash) - -* docs: update Sphinx version on RTD (Jameson Nash) - -* doc: clean up license file (Ben Noordhuis) - -* test: fix some warnings when compiling tests (panran) - -* build,win: add mingw-w64 CI configuration (Jameson Nash) - -* build: add CI for distcheck (Jameson Nash) - -* unix: remove busy loop from uv_async_send (Jameson Nash) - -* doc: document uv_fs_cb type (Tamás Bálint Misius) - -* build: Improve build by cmake for Cygwin (erw7) - -* build: add libuv:: namespace to libuvConfig.cmake (AJ Heller) - -* test: fix ThreadSanitizer thread leak warning (Ben Noordhuis) - -* test: fix ThreadSanitizer data race warning (Ben Noordhuis) - -* test: fix ThreadSanitizer data race warning (Ben Noordhuis) - -* test: fix ThreadSanitizer data race warning (Ben Noordhuis) - -* test: cond-skip fork_threadpool_queue_work_simple (Ben Noordhuis) - -* test: cond-skip signal_multiple_loops (Ben Noordhuis) - -* test: cond-skip tcp_writealot (Ben Noordhuis) - -* build: promote tsan ci to must-pass (Ben Noordhuis) - -* build: add CI for OpenBSD and FreeBSD (James McCoy) - -* build,test: fix distcheck errors (Jameson Nash) - -* test: remove bad tty window size assumption (Ben Noordhuis) - -* darwin,process: feed kevent the signal to reap children (Jameson Nash) - -* unix: abort on clock_gettime() error (Ben Noordhuis) - -* test: remove timing-sensitive check (Ben Noordhuis) - -* unix: DRY and fix tcp bind error path (Jameson Nash) - -* macos: fix fsevents thread race conditions (Ben Noordhuis) - -* win: fix leak in uv_chdir (Trevor Norris) - -* test: make valgrind happy (Trevor Norris) - -* barrier: wait for prior out before next in (Jameson Nash) - -* test: fix visual studio 2015 build error (Ben Noordhuis) - -* linux: fix ceph copy error truncating readonly files (Bruno Passeri) - -* test: silence more valgrind warnings (Trevor Norris) - -* doc: add entries to LINKS.md (Trevor Norris) - -* win,unix: change execution order of timers (Trevor Norris) - -* doc: add trevnorris to maintainers (Trevor Norris) - -* linux: remove epoll_pwait() emulation code path (Ben Noordhuis) - -* linux: replace unsafe macro with inline function (Ben Noordhuis) - -* linux: remove arm oabi support (Ben Noordhuis) - -* unix,sunos: SO_REUSEPORT not valid on all sockets (Stacey Marshall) - -* doc: consistent single backquote in misc.rst (Jason Zhang) - -* src: switch to use C11 atomics where available (Trevor Norris) - -* test: don't use static buffer for formatting (Ben Noordhuis) - -* linux: introduce io_uring support (Ben Noordhuis) - -* linux: fix academic valgrind warning (Ben Noordhuis) - -* test: disable signal test under ASan and MSan (Ben Noordhuis) - -* linux: add IORING_OP_OPENAT support (Ben Noordhuis) - -* linux: add IORING_OP_CLOSE support (Ben Noordhuis) - -* linux: remove bug workaround for obsolete kernels (Ben Noordhuis) - -* doc: update active maintainers list (Ben Noordhuis) - -* test: add ASSERT_OK (Trevor Norris) - -* src: fix events/events_waiting metrics counter (Trevor Norris) - -* unix,win: add uv_clock_gettime() (Ben Noordhuis) - -* build: remove freebsd and openbsd buildbots (Ben Noordhuis) - -* win: fix race condition in uv__init_console() (sivadeilra) - -* linux: fix logic bug in sqe ring space check (Ben Noordhuis) - -* linux: use io_uring to batch epoll_ctl calls (Ben Noordhuis) - -* macos: update minimum supported version (Santiago Gimeno) - -* docs: fix some typos (cui fliter) - -* unix: use memcpy() instead of type punning (Ben Noordhuis) - -* test: add additional assert (Mohammed Keyvanzadeh) - -* build: export compile_commands.json (Lewis Russell) - -* win,process: write minidumps when sending SIGQUIT (Elliot Saba) - -* unix: constrained_memory should return UINT64_MAX (Tim Besard) - -* unix: handle CQ overflow in iou ring (Santiago Gimeno) - -* unix: remove clang compiler warning pragmas (Ben Noordhuis) - -* win: fix mingw build (gengjiawen) - -* test: fix -Wbool-compare compiler warning (Ben Noordhuis) - -* win: define MiniDumpWithAvxXStateContext always (Santiago Gimeno) - -* freebsd: hard-code UV_ENODATA definition (Santiago Gimeno) - -* linux: work around EOWNERDEAD io_uring kernel bug (Ben Noordhuis) - -* linux: fix WRITEV with lots of bufs using io_uring (Santiago Gimeno) - - -2022.07.12, Version 1.44.2 (Stable), 0c1fa696aa502eb749c2c4735005f41ba00a27b8 +2022.07.12, Version 1.44.2 (Stable) Changes since version 1.44.1: diff --git a/LICENSE b/LICENSE index 6566365..eb126da 100644 --- a/LICENSE +++ b/LICENSE @@ -1,3 +1,6 @@ +libuv is licensed for use as follows: + +==== Copyright (c) 2015-present libuv project contributors. Permission is hereby granted, free of charge, to any person obtaining a copy @@ -17,3 +20,47 @@ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +==== + +This license applies to parts of libuv originating from the +https://github.com/joyent/libuv repository: + +==== + +Copyright Joyent, Inc. and other Node contributors. All rights reserved. +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to +deal in the Software without restriction, including without limitation the +rights to use, copy, modify, merge, publish, distribute, sublicense, and/or +sell copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS +IN THE SOFTWARE. + +==== + +This license applies to all parts of libuv that are not externally +maintained libraries. + +The externally maintained libraries used by libuv are: + + - tree.h (from FreeBSD), copyright Niels Provos. Two clause BSD license. + + - inet_pton and inet_ntop implementations, contained in src/inet.c, are + copyright the Internet Systems Consortium, Inc., and licensed under the ISC + license. + + - stdint-msvc2008.h (from msinttypes), copyright Alexander Chemeris. Three + clause BSD license. + + - pthread-fixes.c, copyright Google Inc. and Sony Mobile Communications AB. + Three clause BSD license. diff --git a/LICENSE-extra b/LICENSE-extra deleted file mode 100644 index 7d8ee65..0000000 --- a/LICENSE-extra +++ /dev/null @@ -1,36 +0,0 @@ -This license applies to parts of libuv originating from the -https://github.com/joyent/libuv repository: - -==== - -Copyright Joyent, Inc. and other Node contributors. All rights reserved. -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to -deal in the Software without restriction, including without limitation the -rights to use, copy, modify, merge, publish, distribute, sublicense, and/or -sell copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in -all copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING -FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS -IN THE SOFTWARE. - -==== - -This license applies to all parts of libuv that are not externally -maintained libraries. - -The externally maintained libraries used by libuv are: - - - tree.h (from FreeBSD), copyright Niels Provos. Two clause BSD license. - - - inet_pton and inet_ntop implementations, contained in src/inet.c, are - copyright the Internet Systems Consortium, Inc., and licensed under the ISC - license. diff --git a/LINKS.md b/LINKS.md index 3e58007..b8204e5 100644 --- a/LINKS.md +++ b/LINKS.md @@ -1,20 +1,16 @@ ### Apps / VM -* [AliceO2](https://github.com/AliceO2Group/AliceO2): The framework and detector specific code for the reconstruction, calibration and simulation for the ALICE experiment at CERN. -* [Beam](https://github.com/BeamMW/beam): A scalable, confidential cryptocurrency based on the Mimblewimble protocol. * [BIND 9](https://bind.isc.org/): DNS software system including an authoritative server, a recursive resolver and related utilities. * [cjdns](https://github.com/cjdelisle/cjdns): Encrypted self-configuring network/VPN routing engine * [clearskies_core](https://github.com/larroy/clearskies_core): Clearskies file synchronization program. (C++11) * [CMake](https://cmake.org) open-source, cross-platform family of tools designed to build, test and package software -* [Cocos-Engine](https://github.com/cocos/cocos-engine): The runtime framework for Cocos Creator editor. -* [Coherence](https://github.com/liesware/coherence/): Cryptographic server for modern web apps. -* [DPS8M](https://dps8m.gitlab.io): GE ∕ Honeywell ∕ Bull DPS‑8/M and 6180/L68 mainframe simulator. +* [Coherence](https://github.com/liesware/coherence/): Cryptographic server for modern web apps. * [DPS-For-IoT](https://github.com/intel/dps-for-iot/wiki): Fully distributed publish/subscribe protocol. * [HashLink](https://github.com/HaxeFoundation/hashlink): Haxe run-time with libuv support included. * [Haywire](https://github.com/kellabyte/Haywire): Asynchronous HTTP server. * [H2O](https://github.com/h2o/h2o): An optimized HTTP server with support for HTTP/1.x and HTTP/2. * [Igropyr](https://github.com/guenchi/Igropyr): a async Scheme http server base on libuv. * [Julia](http://julialang.org/): Scientific computing programming language -* [Kestrel](https://github.com/dotnet/aspnetcore/tree/main/src/Servers/Kestrel): web server (C# + libuv + [ASP.NET Core](http://github.com/aspnet)) +* [Kestrel](https://github.com/aspnet/AspNetCore/tree/master/src/Servers/Kestrel): web server (C# + libuv + [ASP.NET Core](http://github.com/aspnet)) * [Knot DNS Resolver](https://www.knot-resolver.cz/): A minimalistic DNS caching resolver * [Lever](http://leverlanguage.com): runtime, libuv at the 0.9.0 release * [libnode](https://github.com/plenluno/libnode): C++ implementation of Node.js @@ -34,10 +30,8 @@ * [phastlight](https://github.com/phastlight/phastlight): Command line tool and web server written in PHP 5.3+ inspired by Node.js * [pilight](https://www.pilight.org/): home automation ("domotica") * [pixie](https://github.com/pixie-lang/pixie): clojure-inspired lisp with a tracing JIT -* [Pixie-io](https://github.com/pixie-io/pixie): Open-source observability tool for Kubernetes applications. * [potion](https://github.com/perl11/potion)/[p2](https://github.com/perl11/p2): runtime * [racer](https://libraries.io/rubygems/racer): Ruby web server written as an C extension -* [Socket Runtime](https://sockets.sh): A runtime for creating native cross-platform software on mobile and desktop using HTML, CSS, and JavaScript * [spider-gazelle](https://github.com/cotag/spider-gazelle): Ruby web server using libuv bindings * [Suave](http://suave.io/): A simple web development F# library providing a lightweight web server and a set of combinators to manipulate route flow and task composition * [Swish](https://github.com/becls/swish/): Concurrency engine with Erlang-like concepts. Includes a web server. @@ -45,7 +39,6 @@ * [Urbit](http://urbit.org): runtime * [uv_callback](https://github.com/litesync/uv_callback) libuv thread communication * [uvloop](https://github.com/MagicStack/uvloop): Ultra fast implementation of python's asyncio event loop on top of libuv -* [WPILib](https://github.com/wpilibsuite/allwpilib): Libraries for creating robot programs for the roboRIO. * [Wren CLI](https://github.com/wren-lang/wren-cli): For io, process, scheduler and timer modules ### Other @@ -66,7 +59,6 @@ * [lluv](https://github.com/moteus/lua-lluv) * C++11 * [uvpp](https://github.com/larroy/uvpp) - Not complete, exposes very few aspects of `libuv` - * [nsuv](https://github.com/nodesource/nsuv) - Template wrapper focused on enforcing compile-time type safety when propagating data * C++17 * [uvw](https://github.com/skypjack/uvw) - Header-only, event based, tiny and easy to use *libuv* wrapper in modern C++. * Python diff --git a/MAINTAINERS.md b/MAINTAINERS.md index 41c60cb..477901f 100644 --- a/MAINTAINERS.md +++ b/MAINTAINERS.md @@ -4,6 +4,12 @@ libuv is currently managed by the following individuals: * **Ben Noordhuis** ([@bnoordhuis](https://github.com/bnoordhuis)) - GPG key: D77B 1E34 243F BAF0 5F8E 9CC3 4F55 C8C8 46AB 89B9 (pubkey-bnoordhuis) +* **Bert Belder** ([@piscisaureus](https://github.com/piscisaureus)) +* **Colin Ihrig** ([@cjihrig](https://github.com/cjihrig)) + - GPG key: 94AE 3667 5C46 4D64 BAFA 68DD 7434 390B DBE9 B9C5 (pubkey-cjihrig) + - GPG key: 5735 3E0D BDAA A7E8 39B6 6A1A FF47 D5E4 AD8B 4FDC (pubkey-cjihrig-kb) +* **Fedor Indutny** ([@indutny](https://github.com/indutny)) + - GPG key: AF2E EA41 EC34 47BF DD86 FED9 D706 3CCE 19B7 E890 (pubkey-indutny) * **Jameson Nash** ([@vtjnash](https://github.com/vtjnash)) - GPG key: AEAD 0A4B 6867 6775 1A0E 4AEF 34A2 5FB1 2824 6514 (pubkey-vtjnash) - GPG key: CFBB 9CA9 A5BE AFD7 0E2B 3C5A 79A6 7C55 A367 9C8B (pubkey2022-vtjnash) @@ -16,19 +22,11 @@ libuv is currently managed by the following individuals: - GPG key: 612F 0EAD 9401 6223 79DF 4402 F28C 3C8D A33C 03BE (pubkey-santigimeno) * **Saúl Ibarra Corretgé** ([@saghul](https://github.com/saghul)) - GPG key: FDF5 1936 4458 319F A823 3DC9 410E 5553 AE9B C059 (pubkey-saghul) -* **Trevor Norris** ([@trevnorris](https://github.com/trevnorris)) - - GPG key: AEFC 279A 0C93 0676 7E58 29A1 251C A676 820D C7F3 (pubkey-trevnorris) ## Project Maintainers emeriti * **Anna Henningsen** ([@addaleax](https://github.com/addaleax)) * **Bartosz Sosnowski** ([@bzoz](https://github.com/bzoz)) -* **Bert Belder** ([@piscisaureus](https://github.com/piscisaureus)) -* **Colin Ihrig** ([@cjihrig](https://github.com/cjihrig)) - - GPG key: 94AE 3667 5C46 4D64 BAFA 68DD 7434 390B DBE9 B9C5 (pubkey-cjihrig) - - GPG key: 5735 3E0D BDAA A7E8 39B6 6A1A FF47 D5E4 AD8B 4FDC (pubkey-cjihrig-kb) -* **Fedor Indutny** ([@indutny](https://github.com/indutny)) - - GPG key: AF2E EA41 EC34 47BF DD86 FED9 D706 3CCE 19B7 E890 (pubkey-indutny) * **Imran Iqbal** ([@imran-iq](https://github.com/imran-iq)) * **John Barboza** ([@jbarz](https://github.com/jbarz)) diff --git a/Makefile.am b/Makefile.am index a14228d..0c6d965 100644 --- a/Makefile.am +++ b/Makefile.am @@ -38,7 +38,6 @@ libuv_la_SOURCES = src/fs-poll.c \ src/random.c \ src/strscpy.c \ src/strscpy.h \ - src/thread-common.c \ src/threadpool.c \ src/timer.c \ src/uv-data-getter-setters.c \ @@ -97,6 +96,7 @@ else # WINNT uvinclude_HEADERS += include/uv/unix.h AM_CPPFLAGS += -I$(top_srcdir)/src/unix libuv_la_SOURCES += src/unix/async.c \ + src/unix/atomic-ops.h \ src/unix/core.c \ src/unix/dl.c \ src/unix/fs.c \ @@ -110,6 +110,7 @@ libuv_la_SOURCES += src/unix/async.c \ src/unix/process.c \ src/unix/random-devurandom.c \ src/unix/signal.c \ + src/unix/spinlock.h \ src/unix/stream.c \ src/unix/tcp.c \ src/unix/thread.c \ @@ -121,13 +122,11 @@ endif # WINNT EXTRA_DIST = test/fixtures/empty_file \ test/fixtures/load_error.node \ test/fixtures/lorem_ipsum.txt \ - test/fixtures/one_file/one_file \ include \ docs \ img \ CONTRIBUTING.md \ LICENSE \ - LICENSE-extra \ README.md @@ -136,12 +135,6 @@ TESTS = test/run-tests check_PROGRAMS = test/run-tests test_run_tests_CFLAGS = $(AM_CFLAGS) -if WINNT -check-am: test/run-tests_no_ext -test/run-tests_no_ext: test/run-tests$(EXEEXT) - cp test/run-tests$(EXEEXT) test/run-tests_no_ext -endif - if SUNOS # Can't be turned into a CC_CHECK_CFLAGS in configure.ac, it makes compilers # on other platforms complain that the argument is unused during compilation. @@ -285,14 +278,11 @@ test_run_tests_SOURCES = test/blackhole-server.c \ test/test-tcp-writealot.c \ test/test-tcp-write-fail.c \ test/test-tcp-try-write.c \ - test/test-tcp-write-in-a-row.c \ test/test-tcp-try-write-error.c \ test/test-tcp-write-queue-order.c \ test/test-test-macros.c \ test/test-thread-equal.c \ test/test-thread.c \ - test/test-thread-affinity.c \ - test/test-thread-priority.c \ test/test-threadpool-cancel.c \ test/test-threadpool.c \ test/test-timer-again.c \ @@ -323,7 +313,6 @@ test_run_tests_SOURCES = test/blackhole-server.c \ test/test-udp-sendmmsg-error.c \ test/test-udp-send-unreachable.c \ test/test-udp-try-send.c \ - test/test-udp-recv-in-a-row.c \ test/test-uname.c \ test/test-walk-handles.c \ test/test-watcher-cross-stop.c @@ -404,6 +393,7 @@ endif if ANDROID libuv_la_CFLAGS += -D_GNU_SOURCE +libuv_la_SOURCES += src/unix/pthread-fixes.c endif if CYGWIN @@ -477,14 +467,22 @@ libuv_la_SOURCES += src/unix/bsd-ifaddrs.c \ src/unix/hurd.c endif +if KFREEBSD +libuv_la_CFLAGS += -D_GNU_SOURCE +endif + if LINUX uvinclude_HEADERS += include/uv/linux.h libuv_la_CFLAGS += -D_GNU_SOURCE -libuv_la_SOURCES += src/unix/linux.c \ +libuv_la_SOURCES += src/unix/linux-core.c \ + src/unix/linux-inotify.c \ + src/unix/linux-syscalls.c \ + src/unix/linux-syscalls.h \ src/unix/procfs-exepath.c \ src/unix/proctitle.c \ src/unix/random-getrandom.c \ - src/unix/random-sysctl-linux.c + src/unix/random-sysctl-linux.c \ + src/unix/epoll.c test_run_tests_LDFLAGS += -lutil endif @@ -548,7 +546,8 @@ libuv_la_CFLAGS += -D_UNIX03_THREADS \ -qXPLINK \ -qFLOAT=IEEE libuv_la_LDFLAGS += -qXPLINK -libuv_la_SOURCES += src/unix/os390.c \ +libuv_la_SOURCES += src/unix/pthread-fixes.c \ + src/unix/os390.c \ src/unix/os390-syscalls.c \ src/unix/proctitle.c endif diff --git a/README.md b/README.md index faf2b26..06486fe 100644 --- a/README.md +++ b/README.md @@ -43,9 +43,7 @@ The ABI/API changes can be tracked [here](http://abi-laboratory.pro/tracker/time ## Licensing -libuv is licensed under the MIT license. Check the [LICENSE](LICENSE) and -[LICENSE-extra](LICENSE-extra) files. - +libuv is licensed under the MIT license. Check the [LICENSE file](LICENSE). The documentation is licensed under the CC BY 4.0 license. Check the [LICENSE-docs file](LICENSE-docs). ## Community @@ -222,15 +220,6 @@ Make sure that you specify the architecture you wish to build for in the "ARCHS" flag. You can specify more than one by delimiting with a space (e.g. "x86_64 i386"). -### Install with vcpkg - -```bash -$ git clone https://github.com/microsoft/vcpkg.git -$ ./bootstrap-vcpkg.bat # for powershell -$ ./bootstrap-vcpkg.sh # for bash -$ ./vcpkg install libuv -``` - ### Running tests Some tests are timing sensitive. Relaxing test timeouts may be necessary diff --git a/SECURITY.md b/SECURITY.md deleted file mode 100644 index 32abba8..0000000 --- a/SECURITY.md +++ /dev/null @@ -1,27 +0,0 @@ -# Security Policy - -## Supported Versions - -Currently, we are providing security updates for the latest release in the v1.x series: - -| Version | Supported | -| ------- | ------------------ | -| Latest v1.x | :white_check_mark: | - -## Reporting a Vulnerability - -If you believe you have found a security vulnerability in `libuv`, please use the [GitHub's private vulnerability reporting feature](https://docs.github.com/en/code-security/security-advisories/guidance-on-reporting-and-writing-information-about-vulnerabilities/privately-reporting-a-security-vulnerability#privately-reporting-a-security-vulnerability) in the [libuv repository](https://github.com/libuv/libuv) to report it to us. - -This will allow us to assess the risk, and make a fix available before we add a bug report to the GitHub repository. - -Please do: - -* Provide as much information as you can about the vulnerability. -* Provide details about your configuration and environment, if applicable. - -Please do not: - -* Post any information about the vulnerability in public places. -* Attempt to exploit the vulnerability yourself. - -We take all security bugs seriously. Thank you for improving the security of `libuv`. We appreciate your efforts and responsible disclosure and will make every effort to acknowledge your contributions. \ No newline at end of file diff --git a/SUPPORTED_PLATFORMS.md b/SUPPORTED_PLATFORMS.md index 8a435d2..0c1dd4e 100644 --- a/SUPPORTED_PLATFORMS.md +++ b/SUPPORTED_PLATFORMS.md @@ -2,10 +2,10 @@ | System | Support type | Supported versions | Notes | |---|---|---|---| -| GNU/Linux | Tier 1 | Linux >= 3.10 with glibc >= 2.17 | | -| macOS | Tier 1 | macOS >= 11 | Currently supported macOS releases | +| GNU/Linux | Tier 1 | Linux >= 2.6.32 with glibc >= 2.12 | | +| macOS | Tier 1 | macOS >= 10.15 | Current and previous macOS release | | Windows | Tier 1 | >= Windows 8 | VS 2015 and later are supported | -| FreeBSD | Tier 2 | >= 12 | | +| FreeBSD | Tier 1 | >= 10 | | | AIX | Tier 2 | >= 6 | Maintainers: @libuv/aix | | IBM i | Tier 2 | >= IBM i 7.2 | Maintainers: @libuv/ibmi | | z/OS | Tier 2 | >= V2R2 | Maintainers: @libuv/zos | diff --git a/autogen.sh b/autogen.sh index cf82cc6..bfd8f3e 100644 --- a/autogen.sh +++ b/autogen.sh @@ -17,7 +17,7 @@ set -eu cd `dirname "$0"` -if [ "${1:-dev}" = "release" ]; then +if [ "${1:-dev}" == "release" ]; then export LIBUV_RELEASE=true else export LIBUV_RELEASE=false diff --git a/cmake-toolchains/cross-mingw32.cmake b/cmake-toolchains/cross-mingw32.cmake deleted file mode 100644 index 3fe1dd6..0000000 --- a/cmake-toolchains/cross-mingw32.cmake +++ /dev/null @@ -1,17 +0,0 @@ -if(NOT HOST_ARCH) - message(SEND_ERROR "-DHOST_ARCH required to be specified") -endif() - -list(APPEND CMAKE_TRY_COMPILE_PLATFORM_VARIABLES - HOST_ARCH - ) - -SET(CMAKE_SYSTEM_NAME Windows) -set(COMPILER_PREFIX "${HOST_ARCH}-w64-mingw32") -find_program(CMAKE_RC_COMPILER NAMES ${COMPILER_PREFIX}-windres) -find_program(CMAKE_C_COMPILER NAMES ${COMPILER_PREFIX}-gcc) -find_program(CMAKE_CXX_COMPILER NAMES ${COMPILER_PREFIX}-g++) - -set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER) -set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY) -set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY) diff --git a/configure.ac b/configure.ac index d4cc003..82d1640 100644 --- a/configure.ac +++ b/configure.ac @@ -13,13 +13,12 @@ # OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. AC_PREREQ(2.57) -AC_INIT([libuv], [1.48.0], [https://github.com/libuv/libuv/issues]) +AC_INIT([libuv], [1.44.2], [https://github.com/libuv/libuv/issues]) AC_CONFIG_MACRO_DIR([m4]) m4_include([m4/libuv-extra-automake-flags.m4]) m4_include([m4/as_case.m4]) m4_include([m4/libuv-check-flags.m4]) AM_INIT_AUTOMAKE([-Wall -Werror foreign subdir-objects] UV_EXTRA_AUTOMAKE_FLAGS) -AM_MAINTAINER_MODE([enable]) # pass --disable-maintainer-mode if autotools may be unavailable AC_CANONICAL_HOST AC_ENABLE_SHARED AC_ENABLE_STATIC @@ -62,7 +61,8 @@ AM_CONDITIONAL([ANDROID], [AS_CASE([$host_os],[linux-android*],[true], [false]) AM_CONDITIONAL([CYGWIN], [AS_CASE([$host_os],[cygwin*], [true], [false])]) AM_CONDITIONAL([DARWIN], [AS_CASE([$host_os],[darwin*], [true], [false])]) AM_CONDITIONAL([DRAGONFLY],[AS_CASE([$host_os],[dragonfly*], [true], [false])]) -AM_CONDITIONAL([FREEBSD], [AS_CASE([$host_os],[freebsd*], [true], [false])]) +AM_CONDITIONAL([FREEBSD], [AS_CASE([$host_os],[*freebsd*], [true], [false])]) +AM_CONDITIONAL([KFREEBSD], [AS_CASE([$host_os],[kfreebsd*], [true], [false])]) AM_CONDITIONAL([HAIKU], [AS_CASE([$host_os],[haiku], [true], [false])]) AM_CONDITIONAL([HURD], [AS_CASE([$host_os],[gnu*], [true], [false])]) AM_CONDITIONAL([LINUX], [AS_CASE([$host_os],[linux*], [true], [false])]) @@ -74,12 +74,12 @@ AM_CONDITIONAL([OS400], [AS_CASE([$host_os],[os400], [true], [false]) AM_CONDITIONAL([SUNOS], [AS_CASE([$host_os],[solaris*], [true], [false])]) AM_CONDITIONAL([WINNT], [AS_CASE([$host_os],[mingw*], [true], [false])]) AS_CASE([$host_os],[mingw*], [ - LIBS="$LIBS -lws2_32 -lpsapi -liphlpapi -luserenv -luser32 -ldbghelp -lole32 -lshell32" -]) -AS_CASE([$host_os], [solaris2.10], [ - CFLAGS="$CFLAGS -DSUNOS_NO_IFADDRS" + LIBS="$LIBS -lws2_32 -lpsapi -liphlpapi -lshell32 -luserenv -luser32" ]) AS_CASE([$host_os], [netbsd*], [AC_CHECK_LIB([kvm], [kvm_open])]) +AS_CASE([$host_os], [kfreebsd*], [ + LIBS="$LIBS -lfreebsd-glue" +]) AS_CASE([$host_os], [haiku], [ LIBS="$LIBS -lnetwork" ]) @@ -88,5 +88,4 @@ AC_CONFIG_FILES([Makefile libuv.pc]) AC_CONFIG_LINKS([test/fixtures/empty_file:test/fixtures/empty_file]) AC_CONFIG_LINKS([test/fixtures/load_error.node:test/fixtures/load_error.node]) AC_CONFIG_LINKS([test/fixtures/lorem_ipsum.txt:test/fixtures/lorem_ipsum.txt]) -AC_CONFIG_LINKS([test/fixtures/one_file/one_file:test/fixtures/one_file/one_file]) AC_OUTPUT diff --git a/docs/requirements.txt b/docs/requirements.txt index 2e310eb..8386e01 100644 --- a/docs/requirements.txt +++ b/docs/requirements.txt @@ -1,36 +1,42 @@ # primary -furo==2023.5.20 -Sphinx==6.1.3 +Sphinx==3.5.4 # dependencies -alabaster==0.7.13 -Babel==2.11.0 -beautifulsoup4==4.12.2 -certifi==2022.12.7 -charset-normalizer==3.0.1 -colorama==0.4.6 -docutils==0.19 -idna==3.4 -imagesize==1.4.1 -importlib-metadata==6.0.0 -Jinja2==3.1.2 -livereload==2.6.3 -MarkupSafe==2.1.2 -packaging==23.0 -Pygments==2.14.0 -pytz==2022.7.1 -requests==2.28.2 -six==1.16.0 -snowballstemmer==2.2.0 -soupsieve==2.4.1 -sphinx-autobuild==2021.3.14 -sphinx-basic-ng==1.0.0b2 +alabaster==0.7.12 +appdirs==1.4.3 +Babel==2.9.0 +CacheControl==0.12.6 +certifi==2019.11.28 +chardet==3.0.4 +colorama==0.4.3 +contextlib2==0.6.0 +distlib==0.3.0 +distro==1.4.0 +docutils==0.16 +html5lib==1.0.1 +idna==2.8 +imagesize==1.2.0 +ipaddr==2.2.0 +Jinja2==2.11.3 +lockfile==0.12.2 +MarkupSafe==1.1.1 +msgpack==0.6.2 +packaging==20.3 +pep517==0.8.2 +progress==1.5 +Pygments==2.8.1 +pyparsing==2.4.6 +pytoml==0.1.21 +pytz==2021.1 +requests==2.22.0 +retrying==1.3.3 +six==1.14.0 +snowballstemmer==2.1.0 +sphinxcontrib-applehelp==1.0.2 sphinxcontrib-devhelp==1.0.2 -sphinxcontrib-htmlhelp==2.0.0 +sphinxcontrib-htmlhelp==1.0.3 sphinxcontrib-jsmath==1.0.1 sphinxcontrib-qthelp==1.0.3 -sphinxcontrib-serializinghtml==1.1.5 -sphinxcontrib.applehelp==1.0.3 -tornado==6.3.2 -urllib3==1.26.14 -zipp==3.11.0 +sphinxcontrib-serializinghtml==1.1.4 +urllib3==1.25.8 +webencodings==0.5.1 diff --git a/docs/src/conf.py b/docs/src/conf.py index 354759a..f6f4325 100644 --- a/docs/src/conf.py +++ b/docs/src/conf.py @@ -118,7 +118,7 @@ pygments_style = 'sphinx' # The theme to use for HTML and HTML Help pages. See the documentation for # a list of builtin themes. -html_theme = 'furo' +html_theme = 'nature' # Theme options are theme-specific and customize the look and feel of a theme # further. For a list of options available for each theme, see the diff --git a/docs/src/design.rst b/docs/src/design.rst index 5a20595..0f5580c 100644 --- a/docs/src/design.rst +++ b/docs/src/design.rst @@ -60,15 +60,16 @@ stages of a loop iteration: :align: center -#. The loop concept of 'now' is initially set. - -#. Due timers are run if the loop was run with ``UV_RUN_DEFAULT``. All active timers scheduled - for a time before the loop's concept of *now* get their callbacks called. +#. The loop concept of 'now' is updated. The event loop caches the current time at the start of + the event loop tick in order to reduce the number of time-related system calls. #. If the loop is *alive* an iteration is started, otherwise the loop will exit immediately. So, when is a loop considered to be *alive*? If a loop has active and ref'd handles, active requests or closing handles it's considered to be *alive*. +#. Due timers are run. All active timers scheduled for a time before the loop's concept of *now* + get their callbacks called. + #. Pending callbacks are called. All I/O callbacks are called right after polling for I/O, for the most part. There are cases, however, in which calling such a callback is deferred for the next loop iteration. If the previous iteration deferred any I/O callback it will be run at this point. @@ -100,11 +101,9 @@ stages of a loop iteration: #. Close callbacks are called. If a handle was closed by calling :c:func:`uv_close` it will get the close callback called. -#. The loop concept of 'now' is updated. - -#. Due timers are run. Note that 'now' is not updated again until the next loop iteration. - So if a timer became due while other timers were being processed, it won't be run until - the following event loop iteration. +#. Special case in case the loop was run with ``UV_RUN_ONCE``, as it implies forward progress. + It's possible that no I/O callbacks were fired after blocking for I/O, but some time has passed + so there might be timers which are due, those timers get their callbacks called. #. Iteration ends. If the loop was run with ``UV_RUN_NOWAIT`` or ``UV_RUN_ONCE`` modes the iteration ends and :c:func:`uv_run` will return. If the loop was run with ``UV_RUN_DEFAULT`` diff --git a/docs/src/errors.rst b/docs/src/errors.rst index a2e94d9..c7240f3 100644 --- a/docs/src/errors.rst +++ b/docs/src/errors.rst @@ -339,9 +339,6 @@ Error constants socket type not supported -.. c:macro:: UV_EUNATCH - - protocol driver not attached API --- diff --git a/docs/src/fs.rst b/docs/src/fs.rst index 891ee74..0bf2abe 100644 --- a/docs/src/fs.rst +++ b/docs/src/fs.rst @@ -12,12 +12,6 @@ otherwise it will be performed asynchronously. All file operations are run on the threadpool. See :ref:`threadpool` for information on the threadpool size. -Starting with libuv v1.45.0, some file operations on Linux are handed off to -`io_uring ` when possible. Apart from -a (sometimes significant) increase in throughput there should be no change in -observable behavior. Libuv reverts to using its threadpool when the necessary -kernel features are unavailable or unsuitable. - .. note:: On Windows `uv_fs_*` functions use utf-8 encoding. @@ -30,8 +24,7 @@ Data types .. c:type:: uv_timespec_t - Y2K38-unsafe data type for storing times with nanosecond resolution. - Will be replaced with :c:type:`uv_timespec64_t` in libuv v2.0. + Portable equivalent of ``struct timespec``. :: @@ -167,10 +160,6 @@ Data types size_t nentries; } uv_dir_t; -.. c:type:: void (*uv_fs_cb)(uv_fs_t* req) - - Callback called when a request is completed asynchronously. - Public members ^^^^^^^^^^^^^^ @@ -229,8 +218,7 @@ API .. c:function:: int uv_fs_read(uv_loop_t* loop, uv_fs_t* req, uv_file file, const uv_buf_t bufs[], unsigned int nbufs, int64_t offset, uv_fs_cb cb) - Equivalent to :man:`preadv(2)`. If the `offset` argument is `-1`, then - the current file offset is used and updated. + Equivalent to :man:`preadv(2)`. .. warning:: On Windows, under non-MSVC environments (e.g. when GCC or Clang is used @@ -243,8 +231,7 @@ API .. c:function:: int uv_fs_write(uv_loop_t* loop, uv_fs_t* req, uv_file file, const uv_buf_t bufs[], unsigned int nbufs, int64_t offset, uv_fs_cb cb) - Equivalent to :man:`pwritev(2)`. If the `offset` argument is `-1`, then - the current file offset is used and updated. + Equivalent to :man:`pwritev(2)`. .. warning:: On Windows, under non-MSVC environments (e.g. when GCC or Clang is used @@ -476,6 +463,10 @@ API The background story and some more details on these issues can be checked `here `_. + .. note:: + This function is not implemented on Windows XP and Windows Server 2003. + On these systems, UV_ENOSYS is returned. + .. versionadded:: 1.8.0 .. c:function:: int uv_fs_chown(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_uid_t uid, uv_gid_t gid, uv_fs_cb cb) diff --git a/docs/src/fs_event.rst b/docs/src/fs_event.rst index 54a776a..e28ec62 100644 --- a/docs/src/fs_event.rst +++ b/docs/src/fs_event.rst @@ -39,12 +39,8 @@ Data types .. c:type:: void (*uv_fs_event_cb)(uv_fs_event_t* handle, const char* filename, int events, int status) Callback passed to :c:func:`uv_fs_event_start` which will be called repeatedly - after the handle is started. - - If the handle was started with a directory the `filename` parameter will - be a relative path to a file contained in the directory, or `NULL` if the - file name cannot be determined. - + after the handle is started. If the handle was started with a directory the + `filename` parameter will be a relative path to a file contained in the directory. The `events` parameter is an ORed mask of :c:type:`uv_fs_event` elements. .. c:type:: uv_fs_event diff --git a/docs/src/guide/networking.rst b/docs/src/guide/networking.rst index 892ade0..dcb5643 100644 --- a/docs/src/guide/networking.rst +++ b/docs/src/guide/networking.rst @@ -164,7 +164,7 @@ IPv6 stack only IPv6 sockets can be used for both IPv4 and IPv6 communication. If you want to restrict the socket to IPv6 only, pass the ``UV_UDP_IPV6ONLY`` flag to -``uv_udp_bind``. +``uv_udp_bind`` [#]_. Multicast ~~~~~~~~~ @@ -250,6 +250,7 @@ times, with each address being reported once. ---- .. [#] https://beej.us/guide/bgnet/html/#broadcast-packetshello-world +.. [#] on Windows only supported on Windows Vista and later. .. [#] https://www.tldp.org/HOWTO/Multicast-HOWTO-6.html#ss6.1 .. [#] libuv use the system ``getaddrinfo`` in the libuv threadpool. libuv v0.8.0 and earlier also included c-ares_ as an alternative, but this has been diff --git a/docs/src/guide/processes.rst b/docs/src/guide/processes.rst index 99d65c4..c1278f1 100644 --- a/docs/src/guide/processes.rst +++ b/docs/src/guide/processes.rst @@ -53,8 +53,6 @@ ID of the child process. The exit callback will be invoked with the *exit status* and the type of *signal* which caused the exit. -Note that it is important **not** to call ``uv_close`` before the exit callback. - .. rubric:: spawn/main.c .. literalinclude:: ../../code/spawn/main.c :language: c @@ -128,8 +126,7 @@ of ``uv_kill`` is:: For processes started using libuv, you may use ``uv_process_kill`` instead, which accepts the ``uv_process_t`` watcher as the first argument, rather than -the pid. In this case, **remember to call** ``uv_close`` on the watcher _after_ -the exit callback has been called. +the pid. In this case, **remember to call** ``uv_close`` on the watcher. Signals ------- diff --git a/docs/src/guide/utilities.rst b/docs/src/guide/utilities.rst index 44e4370..e2f3cf6 100644 --- a/docs/src/guide/utilities.rst +++ b/docs/src/guide/utilities.rst @@ -235,7 +235,7 @@ Our downloader is to be invoked as:: $ ./uvwget [url1] [url2] ... -So we add each argument as a URL +So we add each argument as an URL .. rubric:: uvwget/main.c - Adding urls .. literalinclude:: ../../code/uvwget/main.c @@ -363,7 +363,7 @@ to get the error message. argument. ``init_plugin_function`` is a function pointer to the sort of function we are looking for in the application's plugins. -.. _shared libraries: https://en.wikipedia.org/wiki/Shared_library +.. _shared libraries: https://en.wikipedia.org/wiki/Shared_library#Shared_libraries TTY --- diff --git a/docs/src/handle.rst b/docs/src/handle.rst index e91d6e8..0edb7d7 100644 --- a/docs/src/handle.rst +++ b/docs/src/handle.rst @@ -153,9 +153,6 @@ API In-progress requests, like uv_connect_t or uv_write_t, are cancelled and have their callbacks called asynchronously with status=UV_ECANCELED. - `close_cb` can be `NULL` in cases where no cleanup or deallocation is - necessary. - .. c:function:: void uv_ref(uv_handle_t* handle) Reference the given handle. References are idempotent, that is, if a handle diff --git a/docs/src/metrics.rst b/docs/src/metrics.rst index 0141d03..696c620 100644 --- a/docs/src/metrics.rst +++ b/docs/src/metrics.rst @@ -4,46 +4,8 @@ Metrics operations ====================== -libuv provides a metrics API to track various internal operations of the event -loop. - - -Data types ----------- - -.. c:type:: uv_metrics_t - - The struct that contains event loop metrics. It is recommended to retrieve - these metrics in a :c:type:`uv_prepare_cb` in order to make sure there are - no inconsistencies with the metrics counters. - - :: - - typedef struct { - uint64_t loop_count; - uint64_t events; - uint64_t events_waiting; - /* private */ - uint64_t* reserved[13]; - } uv_metrics_t; - - -Public members -^^^^^^^^^^^^^^ - -.. c:member:: uint64_t uv_metrics_t.loop_count - - Number of event loop iterations. - -.. c:member:: uint64_t uv_metrics_t.events - - Number of events that have been processed by the event handler. - -.. c:member:: uint64_t uv_metrics_t.events_waiting - - Number of events that were waiting to be processed when the event provider - was called. - +libuv provides a metrics API to track the amount of time the event loop has +spent idle in the kernel's event provider. API --- @@ -63,9 +25,3 @@ API :c:type:`UV_METRICS_IDLE_TIME`. .. versionadded:: 1.39.0 - -.. c:function:: int uv_metrics_info(uv_loop_t* loop, uv_metrics_t* metrics) - - Copy the current set of event loop metrics to the ``metrics`` pointer. - - .. versionadded:: 1.45.0 diff --git a/docs/src/misc.rst b/docs/src/misc.rst index 9896183..bae4481 100644 --- a/docs/src/misc.rst +++ b/docs/src/misc.rst @@ -73,8 +73,7 @@ Data types .. c:type:: uv_timeval_t - Y2K38-unsafe data type for storing times with microsecond resolution. - Will be replaced with :c:type:`uv_timeval64_t` in libuv v2.0. + Data type for storing times. :: @@ -85,7 +84,7 @@ Data types .. c:type:: uv_timeval64_t - Y2K38-safe data type for storing times with microsecond resolution. + Alternative data type for storing times. :: @@ -94,28 +93,6 @@ Data types int32_t tv_usec; } uv_timeval64_t; -.. c:type:: uv_timespec64_t - - Y2K38-safe data type for storing times with nanosecond resolution. - - :: - - typedef struct { - int64_t tv_sec; - int32_t tv_nsec; - } uv_timespec64_t; - -.. c:enum:: uv_clock_id - - Clock source for :c:func:`uv_clock_gettime`. - - :: - - typedef enum { - UV_CLOCK_MONOTONIC, - UV_CLOCK_REALTIME - } uv_clock_id; - .. c:type:: uv_rusage_t Data type for resource usage results. @@ -142,10 +119,7 @@ Data types } uv_rusage_t; Members marked with `(X)` are unsupported on Windows. - See :man:`getrusage(2)` for supported fields on UNIX-like platforms. - - The maximum resident set size is reported in kilobytes, the unit most - platforms use natively. + See :man:`getrusage(2)` for supported fields on Unix .. c:type:: uv_cpu_info_t @@ -237,7 +211,7 @@ API type of the stdio streams. For :man:`isatty(3)` equivalent functionality use this function and test - for `UV_TTY`. + for ``UV_TTY``. .. c:function:: int uv_replace_allocator(uv_malloc_func malloc_func, uv_realloc_func realloc_func, uv_calloc_func calloc_func, uv_free_func free_func) @@ -251,8 +225,8 @@ API after all resources have been freed and thus libuv doesn't reference any allocated memory chunk. - On success, it returns 0, if any of the function pointers is `NULL` it - returns `UV_EINVAL`. + On success, it returns 0, if any of the function pointers is NULL it + returns UV_EINVAL. .. warning:: There is no protection against changing the allocator multiple times. If the user changes it they are responsible for making @@ -388,13 +362,6 @@ API Frees the `cpu_infos` array previously allocated with :c:func:`uv_cpu_info`. -.. c:function:: int uv_cpumask_size(void) - - Returns the maximum size of the mask used for process/thread affinities, - or `UV_ENOTSUP` if affinities are not supported on the current platform. - - .. versionadded:: 1.45.0 - .. c:function:: int uv_interface_addresses(uv_interface_address_t** addresses, int* count) Gets address information about the network interfaces on the system. An @@ -574,21 +541,18 @@ API .. c:function:: uint64_t uv_get_free_memory(void) - Gets the amount of free memory available in the system, as reported by - the kernel (in bytes). Returns 0 when unknown. + Gets the amount of free memory available in the system, as reported by the kernel (in bytes). .. c:function:: uint64_t uv_get_total_memory(void) Gets the total amount of physical memory in the system (in bytes). - Returns 0 when unknown. .. c:function:: uint64_t uv_get_constrained_memory(void) - Gets the total amount of memory available to the process (in bytes) based on + Gets the amount of memory available to the process (in bytes) based on limits imposed by the OS. If there is no such constraint, or the constraint - is unknown, `0` is returned. If there is a constraining mechanism, but there - is no constraint set, `UINT64_MAX` is returned. Note that it is not unusual - for this value to be less than or greater than :c:func:`uv_get_total_memory`. + is unknown, `0` is returned. Note that it is not unusual for this value to + be less than or greater than :c:func:`uv_get_total_memory`. .. note:: This function currently only returns a non-zero value on Linux, based @@ -596,23 +560,9 @@ API .. versionadded:: 1.29.0 -.. c:function:: uint64_t uv_get_available_memory(void) - - Gets the amount of free memory that is still available to the process (in bytes). - This differs from :c:func:`uv_get_free_memory` in that it takes into account any - limits imposed by the OS. If there is no such constraint, or the constraint - is unknown, the amount returned will be identical to :c:func:`uv_get_free_memory`. - - .. note:: - This function currently only returns a value that is different from - what :c:func:`uv_get_free_memory` reports on Linux, based - on cgroups if it is present. - - .. versionadded:: 1.45.0 - .. c:function:: uint64_t uv_hrtime(void) - Returns the current high-resolution timestamp. This is expressed in + Returns the current high-resolution real time. This is expressed in nanoseconds. It is relative to an arbitrary time in the past. It is not related to the time of day and therefore not subject to clock drift. The primary use is for measuring performance between intervals. @@ -621,19 +571,6 @@ API Not every platform can support nanosecond resolution; however, this value will always be in nanoseconds. -.. c:function:: int uv_clock_gettime(uv_clock_id clock_id, uv_timespec64_t* ts) - - Obtain the current system time from a high-resolution real-time or monotonic - clock source. - - The real-time clock counts from the UNIX epoch (1970-01-01) and is subject - to time adjustments; it can jump back in time. - - The monotonic clock counts from an arbitrary point in the past and never - jumps back in time. - - .. versionadded:: 1.45.0 - .. c:function:: void uv_print_all_handles(uv_loop_t* loop, FILE* stream) Prints all handles associated with the given `loop` to the given `stream`. @@ -839,50 +776,3 @@ API Causes the calling thread to sleep for `msec` milliseconds. .. versionadded:: 1.34.0 - -String manipulation functions ------------------------------ - -These string utilities are needed internally for dealing with Windows, and are -exported to allow clients to work uniformly with this data when the libuv API -is not complete. - -.. c:function:: size_t uv_utf16_length_as_wtf8(const uint16_t* utf16, ssize_t utf16_len) - - Get the length of a UTF-16 (or UCS-2) `utf16` value after converting it to - WTF-8. If `utf16` is NUL terminated, `utf16_len` can be set to -1, - otherwise it must be specified. - - .. versionadded:: 1.47.0 - -.. c:function:: int uv_utf16_to_wtf8(const uint16_t* utf16, ssize_t utf16_len, char** wtf8_ptr, size_t* wtf8_len_ptr) - - Convert UTF-16 (or UCS-2) data in `utf16` to WTF-8 data in `*wtf8_ptr`. The - `utf16_len` count (in characters) gives the length of `utf16`. If `utf16` - is NUL terminated, `utf16_len` can be set to -1, otherwise it must be - specified. If `wtf8_ptr` is `NULL`, no result will be computed, but the - length (equal to `uv_utf16_length_as_wtf8`) will be stored in `wtf8_ptr`. - If `*wtf8_ptr` is `NULL`, space for the conversion will be allocated and - returned in `wtf8_ptr` and the length will be returned in `wtf8_len_ptr`. - Otherwise, the length of `*wtf8_ptr` must be passed in `wtf8_len_ptr`. The - `wtf8_ptr` must contain an extra space for an extra NUL after the result. - If the result is truncated, `UV_ENOBUFS` will be returned and - `wtf8_len_ptr` will be the length of the required `wtf8_ptr` to contain the - whole result. - - .. versionadded:: 1.47.0 - -.. c:function:: ssize_t uv_wtf8_length_as_utf16(const char* wtf8) - - Get the length in characters of a NUL-terminated WTF-8 `wtf8` value - after converting it to UTF-16 (or UCS-2), including NUL terminator. - - .. versionadded:: 1.47.0 - -.. c:function:: void uv_wtf8_to_utf16(const char* utf8, uint16_t* utf16, size_t utf16_len) - - Convert NUL-terminated WTF-8 data in `wtf8` to UTF-16 (or UCS-2) data - in `utf16`. The `utf16_len` count (in characters) must include space - for the NUL terminator. - - .. versionadded:: 1.47.0 diff --git a/docs/src/pipe.rst b/docs/src/pipe.rst index 4abdc65..5fa83b8 100644 --- a/docs/src/pipe.rst +++ b/docs/src/pipe.rst @@ -55,61 +55,17 @@ API Bind the pipe to a file path (Unix) or a name (Windows). - Does not support Linux abstract namespace sockets, - unlike :c:func:`uv_pipe_bind2`. - - Alias for ``uv_pipe_bind2(handle, name, strlen(name), 0)``. - - .. note:: - Paths on Unix get truncated to ``sizeof(sockaddr_un.sun_path)`` bytes, - typically between 92 and 108 bytes. - -.. c:function:: int uv_pipe_bind2(uv_pipe_t* handle, const char* name, size_t namelen, unsigned int flags) - - Bind the pipe to a file path (Unix) or a name (Windows). - - ``flags`` must be zero or ``UV_PIPE_NO_TRUNCATE``. Returns ``UV_EINVAL`` - for unsupported flags without performing the bind operation. - - Supports Linux abstract namespace sockets. ``namelen`` must include - the leading nul byte but not the trailing nul byte. - - .. versionadded:: 1.46.0 - .. note:: - Paths on Unix get truncated to ``sizeof(sockaddr_un.sun_path)`` bytes, - typically between 92 and 108 bytes, unless the ``UV_PIPE_NO_TRUNCATE`` - flag is specified, in which case an ``UV_EINVAL`` error is returned. + Paths on Unix get truncated to ``sizeof(sockaddr_un.sun_path)`` bytes, typically between + 92 and 108 bytes. .. c:function:: void uv_pipe_connect(uv_connect_t* req, uv_pipe_t* handle, const char* name, uv_connect_cb cb) - Connect to the Unix domain socket or the Windows named pipe. - - Does not support Linux abstract namespace sockets, - unlike :c:func:`uv_pipe_connect2`. - - Alias for ``uv_pipe_connect2(req, handle, name, strlen(name), 0, cb)``. - - .. note:: - Paths on Unix get truncated to ``sizeof(sockaddr_un.sun_path)`` bytes, - typically between 92 and 108 bytes. - -.. c:function:: void uv_pipe_connect2(uv_connect_t* req, uv_pipe_t* handle, const char* name, size_t namelen, unsigned int flags, uv_connect_cb cb) - - Connect to the Unix domain socket or the Windows named pipe. - - ``flags`` must be zero or ``UV_PIPE_NO_TRUNCATE``. Returns ``UV_EINVAL`` - for unsupported flags without performing the connect operation. - - Supports Linux abstract namespace sockets. ``namelen`` must include - the leading nul byte but not the trailing nul byte. - - .. versionadded:: 1.46.0 + Connect to the Unix domain socket or the named pipe. .. note:: - Paths on Unix get truncated to ``sizeof(sockaddr_un.sun_path)`` bytes, - typically between 92 and 108 bytes, unless the ``UV_PIPE_NO_TRUNCATE`` - flag is specified, in which case an ``UV_EINVAL`` error is returned. + Paths on Unix get truncated to ``sizeof(sockaddr_un.sun_path)`` bytes, typically between + 92 and 108 bytes. .. c:function:: int uv_pipe_getsockname(const uv_pipe_t* handle, char* buffer, size_t* size) diff --git a/docs/src/poll.rst b/docs/src/poll.rst index f501089..93a101e 100644 --- a/docs/src/poll.rst +++ b/docs/src/poll.rst @@ -101,9 +101,7 @@ API with one of the `UV_E*` error codes (see :ref:`errors`). The user should not close the socket while the handle is active. If the user does that anyway, the callback *may* be called reporting an error status, but this is - **not** guaranteed. If `status == UV_EBADF` polling is discontinued for the - file handle and no further events will be reported. The user should - then call :c:func:`uv_close` on the handle. + **not** guaranteed. .. note:: Calling :c:func:`uv_poll_start` on a handle that is already active is diff --git a/docs/src/process.rst b/docs/src/process.rst index 8d2fdb3..8acf7db 100644 --- a/docs/src/process.rst +++ b/docs/src/process.rst @@ -85,14 +85,7 @@ Data types * option is only meaningful on Windows systems. On Unix it is silently * ignored. */ - UV_PROCESS_WINDOWS_HIDE_GUI = (1 << 6), - /* - * On Windows, if the path to the program to execute, specified in - * uv_process_options_t's file field, has a directory component, - * search for the exact file name before trying variants with - * extensions like '.exe' or '.cmd'. - */ - UV_PROCESS_WINDOWS_FILE_PATH_EXACT_NAME = (1 << 7) + UV_PROCESS_WINDOWS_HIDE_GUI = (1 << 6) }; .. c:type:: uv_stdio_container_t @@ -269,9 +262,6 @@ API .. versionchanged:: 1.24.0 Added `UV_PROCESS_WINDOWS_HIDE_CONSOLE` and `UV_PROCESS_WINDOWS_HIDE_GUI` flags. - .. versionchanged:: 1.48.0 Added the - `UV_PROCESS_WINDOWS_FILE_PATH_EXACT_NAME` flag. - .. c:function:: int uv_process_kill(uv_process_t* handle, int signum) Sends the specified signal to the given process handle. Check the documentation diff --git a/docs/src/static/loop_iteration.png b/docs/src/static/loop_iteration.png index 1545f84a8dcd1cf7b5035f467fea69321e230302..e769cf338b4456ea688b0abf888b646a4253e0eb 100644 GIT binary patch literal 80528 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

IlG||>&m()vh!j1bs%Xt$;1BU+W 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 h)1)Z$|JO#hSTzskPU)K35a diff --git a/docs/src/threading.rst b/docs/src/threading.rst index 883218f..7ca1d4b 100644 --- a/docs/src/threading.rst +++ b/docs/src/threading.rst @@ -88,65 +88,10 @@ Threads .. versionadded:: 1.26.0 -.. c:function:: int uv_thread_setaffinity(uv_thread_t* tid, char* cpumask, char* oldmask, size_t mask_size) - - Sets the specified thread's affinity to cpumask, which is specified in - bytes. Optionally returning the previous affinity setting in oldmask. - On Unix, uses :man:`pthread_getaffinity_np(3)` to get the affinity setting - and maps the cpu_set_t to bytes in oldmask. Then maps the bytes in cpumask - to a cpu_set_t and uses :man:`pthread_setaffinity_np(3)`. On Windows, maps - the bytes in cpumask to a bitmask and uses SetThreadAffinityMask() which - returns the previous affinity setting. - - The mask_size specifies the number of entries (bytes) in cpumask / oldmask, - and must be greater-than-or-equal-to :c:func:`uv_cpumask_size`. - - .. note:: - Thread affinity setting is not atomic on Windows. Unsupported on macOS. - - .. versionadded:: 1.45.0 - -.. c:function:: int uv_thread_getaffinity(uv_thread_t* tid, char* cpumask, size_t mask_size) - - Gets the specified thread's affinity setting. On Unix, this maps the - cpu_set_t returned by :man:`pthread_getaffinity_np(3)` to bytes in cpumask. - - The mask_size specifies the number of entries (bytes) in cpumask, - and must be greater-than-or-equal-to :c:func:`uv_cpumask_size`. - - .. note:: - Thread affinity getting is not atomic on Windows. Unsupported on macOS. - - .. versionadded:: 1.45.0 - -.. c:function:: int uv_thread_getcpu(void) - - Gets the CPU number on which the calling thread is running. - - .. note:: - Currently only implemented on Windows, Linux and FreeBSD. - - .. versionadded:: 1.45.0 - .. c:function:: uv_thread_t uv_thread_self(void) .. c:function:: int uv_thread_join(uv_thread_t *tid) .. c:function:: int uv_thread_equal(const uv_thread_t* t1, const uv_thread_t* t2) -.. c:function:: int uv_thread_setpriority(uv_thread_t tid, int priority) - If the function succeeds, the return value is 0. - If the function fails, the return value is less than zero. - Sets the scheduling priority of the thread specified by tid. It requires elevated - privilege to set specific priorities on some platforms. - The priority can be set to the following constants. UV_THREAD_PRIORITY_HIGHEST, - UV_THREAD_PRIORITY_ABOVE_NORMAL, UV_THREAD_PRIORITY_NORMAL, - UV_THREAD_PRIORITY_BELOW_NORMAL, UV_THREAD_PRIORITY_LOWEST. -.. c:function:: int uv_thread_getpriority(uv_thread_t tid, int* priority) - If the function succeeds, the return value is 0. - If the function fails, the return value is less than zero. - Retrieves the scheduling priority of the thread specified by tid. The value in the - output parameter priority is platform dependent. - For Linux, when schedule policy is SCHED_OTHER (default), priority is 0. - Thread-local storage ^^^^^^^^^^^^^^^^^^^^ diff --git a/docs/src/threadpool.rst b/docs/src/threadpool.rst index 7cfa797..cf6cdc1 100644 --- a/docs/src/threadpool.rst +++ b/docs/src/threadpool.rst @@ -14,9 +14,6 @@ is 1024). .. versionchanged:: 1.30.0 the maximum UV_THREADPOOL_SIZE allowed was increased from 128 to 1024. -.. versionchanged:: 1.45.0 threads now have an 8 MB stack instead of the - (sometimes too low) platform default. - The threadpool is global and shared across all event loops. When a particular function makes use of the threadpool (i.e. when using :c:func:`uv_queue_work`) libuv preallocates and initializes the maximum number of threads allowed by diff --git a/docs/src/udp.rst b/docs/src/udp.rst index d7da95e..009767d 100644 --- a/docs/src/udp.rst +++ b/docs/src/udp.rst @@ -56,7 +56,7 @@ Data types /* * Indicates if IP_RECVERR/IPV6_RECVERR will be set when binding the handle. * This sets IP_RECVERR for IPv4 and IPV6_RECVERR for IPv6 UDP sockets on - * Linux. This stops the Linux kernel from suppressing some ICMP error messages + * Linux. This stops the Linux kernel from supressing some ICMP error messages * and enables full ICMP error reporting for faster failover. * This flag is no-op on platforms other than Linux. */ diff --git a/include/uv.h b/include/uv.h index 418796d..ad32d60 100644 --- a/include/uv.h +++ b/include/uv.h @@ -31,7 +31,6 @@ extern "C" { #error "Define either BUILDING_UV_SHARED or USING_UV_SHARED, not both." #endif -#ifndef UV_EXTERN #ifdef _WIN32 /* Windows - set up dll import/export decorators. */ # if defined(BUILDING_UV_SHARED) @@ -51,19 +50,17 @@ extern "C" { #else # define UV_EXTERN /* nothing */ #endif -#endif /* UV_EXTERN */ #include "uv/errno.h" #include "uv/version.h" #include #include -#include -/* Internal type, do not use. */ -struct uv__queue { - struct uv__queue* next; - struct uv__queue* prev; -}; +#if defined(_MSC_VER) && _MSC_VER < 1600 +# include "uv/stdint-msvc2008.h" +#else +# include +#endif #if defined(_WIN32) # include "uv/win.h" @@ -155,8 +152,6 @@ struct uv__queue { XX(EFTYPE, "inappropriate file type or format") \ XX(EILSEQ, "illegal byte sequence") \ XX(ESOCKTNOSUPPORT, "socket type not supported") \ - XX(ENODATA, "no data available") \ - XX(EUNATCH, "protocol driver not attached") \ #define UV_HANDLE_TYPE_MAP(XX) \ XX(ASYNC, async) \ @@ -264,12 +259,9 @@ typedef struct uv_cpu_info_s uv_cpu_info_t; typedef struct uv_interface_address_s uv_interface_address_t; typedef struct uv_dirent_s uv_dirent_t; typedef struct uv_passwd_s uv_passwd_t; -typedef struct uv_group_s uv_group_t; typedef struct uv_utsname_s uv_utsname_t; typedef struct uv_statfs_s uv_statfs_t; -typedef struct uv_metrics_s uv_metrics_t; - typedef enum { UV_LOOP_BLOCK_SIGNAL = 0, UV_METRICS_IDLE_TIME @@ -302,13 +294,13 @@ UV_EXTERN int uv_loop_init(uv_loop_t* loop); UV_EXTERN int uv_loop_close(uv_loop_t* loop); /* * NOTE: - * This function is DEPRECATED, users should + * This function is DEPRECATED (to be removed after 0.12), users should * allocate the loop manually and use uv_loop_init instead. */ UV_EXTERN uv_loop_t* uv_loop_new(void); /* * NOTE: - * This function is DEPRECATED. Users should use + * This function is DEPRECATED (to be removed after 0.12). Users should use * uv_loop_close and free the memory manually instead. */ UV_EXTERN void uv_loop_delete(uv_loop_t*); @@ -366,32 +358,11 @@ typedef void (*uv_random_cb)(uv_random_t* req, void* buf, size_t buflen); -typedef enum { - UV_CLOCK_MONOTONIC, - UV_CLOCK_REALTIME -} uv_clock_id; - -/* XXX(bnoordhuis) not 2038-proof, https://github.com/libuv/libuv/issues/3864 */ typedef struct { long tv_sec; long tv_nsec; } uv_timespec_t; -typedef struct { - int64_t tv_sec; - int32_t tv_nsec; -} uv_timespec64_t; - -/* XXX(bnoordhuis) not 2038-proof, https://github.com/libuv/libuv/issues/3864 */ -typedef struct { - long tv_sec; - long tv_usec; -} uv_timeval_t; - -typedef struct { - int64_t tv_sec; - int32_t tv_usec; -} uv_timeval64_t; typedef struct { uint64_t st_dev; @@ -480,7 +451,7 @@ struct uv_shutdown_s { uv_handle_type type; \ /* private */ \ uv_close_cb close_cb; \ - struct uv__queue handle_queue; \ + void* handle_queue[2]; \ union { \ int fd; \ void* reserved[4]; \ @@ -822,10 +793,6 @@ inline int uv_tty_set_mode(uv_tty_t* handle, int mode) { UV_EXTERN uv_handle_type uv_guess_handle(uv_file file); -enum { - UV_PIPE_NO_TRUNCATE = 1u << 0 -}; - /* * uv_pipe_t is a subclass of uv_stream_t. * @@ -842,20 +809,10 @@ struct uv_pipe_s { UV_EXTERN int uv_pipe_init(uv_loop_t*, uv_pipe_t* handle, int ipc); UV_EXTERN int uv_pipe_open(uv_pipe_t*, uv_file file); UV_EXTERN int uv_pipe_bind(uv_pipe_t* handle, const char* name); -UV_EXTERN int uv_pipe_bind2(uv_pipe_t* handle, - const char* name, - size_t namelen, - unsigned int flags); UV_EXTERN void uv_pipe_connect(uv_connect_t* req, uv_pipe_t* handle, const char* name, uv_connect_cb cb); -UV_EXTERN int uv_pipe_connect2(uv_connect_t* req, - uv_pipe_t* handle, - const char* name, - size_t namelen, - unsigned int flags, - uv_connect_cb cb); UV_EXTERN int uv_pipe_getsockname(const uv_pipe_t* handle, char* buffer, size_t* size); @@ -1120,14 +1077,7 @@ enum uv_process_flags { * option is only meaningful on Windows systems. On Unix it is silently * ignored. */ - UV_PROCESS_WINDOWS_HIDE_GUI = (1 << 6), - /* - * On Windows, if the path to the program to execute, specified in - * uv_process_options_t's file field, has a directory component, - * search for the exact file name before trying variants with - * extensions like '.exe' or '.cmd'. - */ - UV_PROCESS_WINDOWS_FILE_PATH_EXACT_NAME = (1 << 7) + UV_PROCESS_WINDOWS_HIDE_GUI = (1 << 6) }; /* @@ -1230,12 +1180,6 @@ struct uv_passwd_s { char* homedir; }; -struct uv_group_s { - char* groupname; - unsigned long gid; - char** members; -}; - struct uv_utsname_s { char sysname[256]; char release[256]; @@ -1281,6 +1225,16 @@ UV_EXTERN int uv_uptime(double* uptime); UV_EXTERN uv_os_fd_t uv_get_osfhandle(int fd); UV_EXTERN int uv_open_osfhandle(uv_os_fd_t os_fd); +typedef struct { + long tv_sec; + long tv_usec; +} uv_timeval_t; + +typedef struct { + int64_t tv_sec; + int32_t tv_usec; +} uv_timeval64_t; + typedef struct { uv_timeval_t ru_utime; /* user CPU time used */ uv_timeval_t ru_stime; /* system CPU time used */ @@ -1306,9 +1260,6 @@ UV_EXTERN int uv_os_homedir(char* buffer, size_t* size); UV_EXTERN int uv_os_tmpdir(char* buffer, size_t* size); UV_EXTERN int uv_os_get_passwd(uv_passwd_t* pwd); UV_EXTERN void uv_os_free_passwd(uv_passwd_t* pwd); -UV_EXTERN int uv_os_get_passwd2(uv_passwd_t* pwd, uv_uid_t uid); -UV_EXTERN int uv_os_get_group(uv_group_t* grp, uv_uid_t gid); -UV_EXTERN void uv_os_free_group(uv_group_t* grp); UV_EXTERN uv_pid_t uv_os_getpid(void); UV_EXTERN uv_pid_t uv_os_getppid(void); @@ -1332,21 +1283,9 @@ UV_EXTERN uv_pid_t uv_os_getppid(void); UV_EXTERN int uv_os_getpriority(uv_pid_t pid, int* priority); UV_EXTERN int uv_os_setpriority(uv_pid_t pid, int priority); -enum { - UV_THREAD_PRIORITY_HIGHEST = 2, - UV_THREAD_PRIORITY_ABOVE_NORMAL = 1, - UV_THREAD_PRIORITY_NORMAL = 0, - UV_THREAD_PRIORITY_BELOW_NORMAL = -1, - UV_THREAD_PRIORITY_LOWEST = -2, -}; - -UV_EXTERN int uv_thread_getpriority(uv_thread_t tid, int* priority); -UV_EXTERN int uv_thread_setpriority(uv_thread_t tid, int priority); - UV_EXTERN unsigned int uv_available_parallelism(void); UV_EXTERN int uv_cpu_info(uv_cpu_info_t** cpu_infos, int* count); UV_EXTERN void uv_free_cpu_info(uv_cpu_info_t* cpu_infos, int count); -UV_EXTERN int uv_cpumask_size(void); UV_EXTERN int uv_interface_addresses(uv_interface_address_t** addresses, int* count); @@ -1379,15 +1318,6 @@ UV_EXTERN int uv_os_gethostname(char* buffer, size_t* size); UV_EXTERN int uv_os_uname(uv_utsname_t* buffer); -struct uv_metrics_s { - uint64_t loop_count; - uint64_t events; - uint64_t events_waiting; - /* private */ - uint64_t* reserved[13]; -}; - -UV_EXTERN int uv_metrics_info(uv_loop_t* loop, uv_metrics_t* metrics); UV_EXTERN uint64_t uv_metrics_idle_time(uv_loop_t* loop); typedef enum { @@ -1821,9 +1751,7 @@ UV_EXTERN int uv_chdir(const char* dir); UV_EXTERN uint64_t uv_get_free_memory(void); UV_EXTERN uint64_t uv_get_total_memory(void); UV_EXTERN uint64_t uv_get_constrained_memory(void); -UV_EXTERN uint64_t uv_get_available_memory(void); -UV_EXTERN int uv_clock_gettime(uv_clock_id clock_id, uv_timespec64_t* ts); UV_EXTERN uint64_t uv_hrtime(void); UV_EXTERN void uv_sleep(unsigned int msec); @@ -1900,14 +1828,6 @@ UV_EXTERN int uv_thread_create_ex(uv_thread_t* tid, const uv_thread_options_t* params, uv_thread_cb entry, void* arg); -UV_EXTERN int uv_thread_setaffinity(uv_thread_t* tid, - char* cpumask, - char* oldmask, - size_t mask_size); -UV_EXTERN int uv_thread_getaffinity(uv_thread_t* tid, - char* cpumask, - size_t mask_size); -UV_EXTERN int uv_thread_getcpu(void); UV_EXTERN uv_thread_t uv_thread_self(void); UV_EXTERN int uv_thread_join(uv_thread_t *tid); UV_EXTERN int uv_thread_equal(const uv_thread_t* t1, const uv_thread_t* t2); @@ -1936,7 +1856,7 @@ struct uv_loop_s { void* data; /* Loop reference counting. */ unsigned int active_handles; - struct uv__queue handle_queue; + void* handle_queue[2]; union { void* unused; unsigned int count; @@ -1953,18 +1873,6 @@ UV_EXTERN void uv_loop_set_data(uv_loop_t*, void* data); UV_EXTERN int uv_register_task_to_event(struct uv_loop_s* loop, uv_post_task func, void* handler); UV_EXTERN int uv_unregister_task_to_event(struct uv_loop_s* loop); UV_EXTERN int uv_check_data_valid(struct uv_loop_data* data); -/* String utilities needed internally for dealing with Windows. */ -size_t uv_utf16_length_as_wtf8(const uint16_t* utf16, - ssize_t utf16_len); -int uv_utf16_to_wtf8(const uint16_t* utf16, - ssize_t utf16_len, - char** wtf8_ptr, - size_t* wtf8_len_ptr); -ssize_t uv_wtf8_length_as_utf16(const char* wtf8); -void uv_wtf8_to_utf16(const char* wtf8, - uint16_t* utf16, - size_t utf16_len); - /* Don't export the private CPP symbols. */ #undef UV_HANDLE_TYPE_PRIVATE #undef UV_REQ_TYPE_PRIVATE diff --git a/include/uv/darwin.h b/include/uv/darwin.h index 06962bf..d226415 100644 --- a/include/uv/darwin.h +++ b/include/uv/darwin.h @@ -40,7 +40,7 @@ void* cf_state; \ uv_mutex_t cf_mutex; \ uv_sem_t cf_sem; \ - struct uv__queue cf_signals; \ + void* cf_signals[2]; \ #define UV_PLATFORM_FS_EVENT_FIELDS \ uv__io_t event_watcher; \ @@ -48,8 +48,8 @@ int realpath_len; \ int cf_flags; \ uv_async_t* cf_cb; \ - struct uv__queue cf_events; \ - struct uv__queue cf_member; \ + void* cf_events[2]; \ + void* cf_member[2]; \ int cf_error; \ uv_mutex_t cf_mutex; \ diff --git a/include/uv/errno.h b/include/uv/errno.h index 127278e..71906b3 100644 --- a/include/uv/errno.h +++ b/include/uv/errno.h @@ -413,6 +413,7 @@ #elif defined(__APPLE__) || \ defined(__DragonFly__) || \ defined(__FreeBSD__) || \ + defined(__FreeBSD_kernel__) || \ defined(__NetBSD__) || \ defined(__OpenBSD__) # define UV__EHOSTDOWN (-64) @@ -456,22 +457,4 @@ # define UV__ESOCKTNOSUPPORT (-4025) #endif -/* FreeBSD defines ENODATA in /usr/include/c++/v1/errno.h which is only visible - * if C++ is being used. Define it directly to avoid problems when integrating - * libuv in a C++ project. - */ -#if defined(ENODATA) && !defined(_WIN32) -# define UV__ENODATA UV__ERR(ENODATA) -#elif defined(__FreeBSD__) -# define UV__ENODATA (-9919) -#else -# define UV__ENODATA (-4024) -#endif - -#if defined(EUNATCH) && !defined(_WIN32) -# define UV__EUNATCH UV__ERR(EUNATCH) -#else -# define UV__EUNATCH (-4023) -#endif - #endif /* UV_ERRNO_H_ */ diff --git a/include/uv/linux.h b/include/uv/linux.h index 9f22f8c..9b38405 100644 --- a/include/uv/linux.h +++ b/include/uv/linux.h @@ -28,7 +28,7 @@ int inotify_fd; \ #define UV_PLATFORM_FS_EVENT_FIELDS \ - struct uv__queue watchers; \ + void* watchers[2]; \ int wd; \ #endif /* UV_LINUX_H */ diff --git a/include/uv/stdint-msvc2008.h b/include/uv/stdint-msvc2008.h new file mode 100644 index 0000000..d02608a --- /dev/null +++ b/include/uv/stdint-msvc2008.h @@ -0,0 +1,247 @@ +// ISO C9x compliant stdint.h for Microsoft Visual Studio +// Based on ISO/IEC 9899:TC2 Committee draft (May 6, 2005) WG14/N1124 +// +// Copyright (c) 2006-2008 Alexander Chemeris +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// 1. Redistributions of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// +// 3. The name of the author may be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED +// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO +// EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; +// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, +// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR +// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF +// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +/////////////////////////////////////////////////////////////////////////////// + +#ifndef _MSC_VER // [ +#error "Use this header only with Microsoft Visual C++ compilers!" +#endif // _MSC_VER ] + +#ifndef _MSC_STDINT_H_ // [ +#define _MSC_STDINT_H_ + +#if _MSC_VER > 1000 +#pragma once +#endif + +#include + +// For Visual Studio 6 in C++ mode and for many Visual Studio versions when +// compiling for ARM we should wrap include with 'extern "C++" {}' +// or compiler give many errors like this: +// error C2733: second C linkage of overloaded function 'wmemchr' not allowed +#ifdef __cplusplus +extern "C" { +#endif +# include +#ifdef __cplusplus +} +#endif + +// Define _W64 macros to mark types changing their size, like intptr_t. +#ifndef _W64 +# if !defined(__midl) && (defined(_X86_) || defined(_M_IX86)) && _MSC_VER >= 1300 +# define _W64 __w64 +# else +# define _W64 +# endif +#endif + + +// 7.18.1 Integer types + +// 7.18.1.1 Exact-width integer types + +// Visual Studio 6 and Embedded Visual C++ 4 doesn't +// realize that, e.g. char has the same size as __int8 +// so we give up on __intX for them. +#if (_MSC_VER < 1300) + typedef signed char int8_t; + typedef signed short int16_t; + typedef signed int int32_t; + typedef unsigned char uint8_t; + typedef unsigned short uint16_t; + typedef unsigned int uint32_t; +#else + typedef signed __int8 int8_t; + typedef signed __int16 int16_t; + typedef signed __int32 int32_t; + typedef unsigned __int8 uint8_t; + typedef unsigned __int16 uint16_t; + typedef unsigned __int32 uint32_t; +#endif +typedef signed __int64 int64_t; +typedef unsigned __int64 uint64_t; + + +// 7.18.1.2 Minimum-width integer types +typedef int8_t int_least8_t; +typedef int16_t int_least16_t; +typedef int32_t int_least32_t; +typedef int64_t int_least64_t; +typedef uint8_t uint_least8_t; +typedef uint16_t uint_least16_t; +typedef uint32_t uint_least32_t; +typedef uint64_t uint_least64_t; + +// 7.18.1.3 Fastest minimum-width integer types +typedef int8_t int_fast8_t; +typedef int16_t int_fast16_t; +typedef int32_t int_fast32_t; +typedef int64_t int_fast64_t; +typedef uint8_t uint_fast8_t; +typedef uint16_t uint_fast16_t; +typedef uint32_t uint_fast32_t; +typedef uint64_t uint_fast64_t; + +// 7.18.1.4 Integer types capable of holding object pointers +#ifdef _WIN64 // [ + typedef signed __int64 intptr_t; + typedef unsigned __int64 uintptr_t; +#else // _WIN64 ][ + typedef _W64 signed int intptr_t; + typedef _W64 unsigned int uintptr_t; +#endif // _WIN64 ] + +// 7.18.1.5 Greatest-width integer types +typedef int64_t intmax_t; +typedef uint64_t uintmax_t; + + +// 7.18.2 Limits of specified-width integer types + +#if !defined(__cplusplus) || defined(__STDC_LIMIT_MACROS) // [ See footnote 220 at page 257 and footnote 221 at page 259 + +// 7.18.2.1 Limits of exact-width integer types +#define INT8_MIN ((int8_t)_I8_MIN) +#define INT8_MAX _I8_MAX +#define INT16_MIN ((int16_t)_I16_MIN) +#define INT16_MAX _I16_MAX +#define INT32_MIN ((int32_t)_I32_MIN) +#define INT32_MAX _I32_MAX +#define INT64_MIN ((int64_t)_I64_MIN) +#define INT64_MAX _I64_MAX +#define UINT8_MAX _UI8_MAX +#define UINT16_MAX _UI16_MAX +#define UINT32_MAX _UI32_MAX +#define UINT64_MAX _UI64_MAX + +// 7.18.2.2 Limits of minimum-width integer types +#define INT_LEAST8_MIN INT8_MIN +#define INT_LEAST8_MAX INT8_MAX +#define INT_LEAST16_MIN INT16_MIN +#define INT_LEAST16_MAX INT16_MAX +#define INT_LEAST32_MIN INT32_MIN +#define INT_LEAST32_MAX INT32_MAX +#define INT_LEAST64_MIN INT64_MIN +#define INT_LEAST64_MAX INT64_MAX +#define UINT_LEAST8_MAX UINT8_MAX +#define UINT_LEAST16_MAX UINT16_MAX +#define UINT_LEAST32_MAX UINT32_MAX +#define UINT_LEAST64_MAX UINT64_MAX + +// 7.18.2.3 Limits of fastest minimum-width integer types +#define INT_FAST8_MIN INT8_MIN +#define INT_FAST8_MAX INT8_MAX +#define INT_FAST16_MIN INT16_MIN +#define INT_FAST16_MAX INT16_MAX +#define INT_FAST32_MIN INT32_MIN +#define INT_FAST32_MAX INT32_MAX +#define INT_FAST64_MIN INT64_MIN +#define INT_FAST64_MAX INT64_MAX +#define UINT_FAST8_MAX UINT8_MAX +#define UINT_FAST16_MAX UINT16_MAX +#define UINT_FAST32_MAX UINT32_MAX +#define UINT_FAST64_MAX UINT64_MAX + +// 7.18.2.4 Limits of integer types capable of holding object pointers +#ifdef _WIN64 // [ +# define INTPTR_MIN INT64_MIN +# define INTPTR_MAX INT64_MAX +# define UINTPTR_MAX UINT64_MAX +#else // _WIN64 ][ +# define INTPTR_MIN INT32_MIN +# define INTPTR_MAX INT32_MAX +# define UINTPTR_MAX UINT32_MAX +#endif // _WIN64 ] + +// 7.18.2.5 Limits of greatest-width integer types +#define INTMAX_MIN INT64_MIN +#define INTMAX_MAX INT64_MAX +#define UINTMAX_MAX UINT64_MAX + +// 7.18.3 Limits of other integer types + +#ifdef _WIN64 // [ +# define PTRDIFF_MIN _I64_MIN +# define PTRDIFF_MAX _I64_MAX +#else // _WIN64 ][ +# define PTRDIFF_MIN _I32_MIN +# define PTRDIFF_MAX _I32_MAX +#endif // _WIN64 ] + +#define SIG_ATOMIC_MIN INT_MIN +#define SIG_ATOMIC_MAX INT_MAX + +#ifndef SIZE_MAX // [ +# ifdef _WIN64 // [ +# define SIZE_MAX _UI64_MAX +# else // _WIN64 ][ +# define SIZE_MAX _UI32_MAX +# endif // _WIN64 ] +#endif // SIZE_MAX ] + +// WCHAR_MIN and WCHAR_MAX are also defined in +#ifndef WCHAR_MIN // [ +# define WCHAR_MIN 0 +#endif // WCHAR_MIN ] +#ifndef WCHAR_MAX // [ +# define WCHAR_MAX _UI16_MAX +#endif // WCHAR_MAX ] + +#define WINT_MIN 0 +#define WINT_MAX _UI16_MAX + +#endif // __STDC_LIMIT_MACROS ] + + +// 7.18.4 Limits of other integer types + +#if !defined(__cplusplus) || defined(__STDC_CONSTANT_MACROS) // [ See footnote 224 at page 260 + +// 7.18.4.1 Macros for minimum-width integer constants + +#define INT8_C(val) val##i8 +#define INT16_C(val) val##i16 +#define INT32_C(val) val##i32 +#define INT64_C(val) val##i64 + +#define UINT8_C(val) val##ui8 +#define UINT16_C(val) val##ui16 +#define UINT32_C(val) val##ui32 +#define UINT64_C(val) val##ui64 + +// 7.18.4.2 Macros for greatest-width integer constants +#define INTMAX_C INT64_C +#define UINTMAX_C UINT64_C + +#endif // __STDC_CONSTANT_MACROS ] + + +#endif // _MSC_STDINT_H_ ] diff --git a/include/uv/threadpool.h b/include/uv/threadpool.h index 190d205..3797cb8 100644 --- a/include/uv/threadpool.h +++ b/include/uv/threadpool.h @@ -50,7 +50,7 @@ struct uv_work_dump_info { struct uv__work* work; - struct uv__queue wq; + void* wq[2]; }; struct uv__statistic_work { @@ -58,7 +58,7 @@ struct uv__statistic_work { struct uv_work_dump_info* info; enum uv_work_state state; uint64_t time; - struct uv__queue wq; + void* wq[2]; }; #endif @@ -66,7 +66,7 @@ struct uv__work { void (*work)(struct uv__work *w); void (*done)(struct uv__work *w, int status); struct uv_loop_s* loop; - struct uv__queue wq; + void* wq[2]; #ifdef UV_STATISTIC struct uv_work_dump_info* info; #endif diff --git a/include/uv/unix.h b/include/uv/unix.h index 88e0c05..ab694b5 100644 --- a/include/uv/unix.h +++ b/include/uv/unix.h @@ -59,6 +59,7 @@ # include "uv/darwin.h" #elif defined(__DragonFly__) || \ defined(__FreeBSD__) || \ + defined(__FreeBSD_kernel__) || \ defined(__OpenBSD__) || \ defined(__NetBSD__) # include "uv/bsd.h" @@ -92,8 +93,8 @@ typedef struct uv__io_s uv__io_t; struct uv__io_s { uv__io_cb cb; - struct uv__queue pending_queue; - struct uv__queue watcher_queue; + void* pending_queue[2]; + void* watcher_queue[2]; unsigned int pevents; /* Pending event mask i.e. mask at next tick. */ unsigned int events; /* Current event mask. */ int fd; @@ -221,21 +222,21 @@ typedef struct { unsigned int magic; \ unsigned long flags; \ int backend_fd; \ - struct uv__queue pending_queue; \ - struct uv__queue watcher_queue; \ + void* pending_queue[2]; \ + void* watcher_queue[2]; \ uv__io_t** watchers; \ unsigned int nwatchers; \ unsigned int nfds; \ - struct uv__queue wq; \ + void* wq[2]; \ uv_mutex_t wq_mutex; \ uv_async_t wq_async; \ uv_rwlock_t cloexec_lock; \ uv_handle_t* closing_handles; \ - struct uv__queue process_handles; \ - struct uv__queue prepare_handles; \ - struct uv__queue check_handles; \ - struct uv__queue idle_handles; \ - struct uv__queue async_handles; \ + void* process_handles[2]; \ + void* prepare_handles[2]; \ + void* check_handles[2]; \ + void* idle_handles[2]; \ + void* async_handles[2]; \ void (*async_unused)(void); /* TODO(bnoordhuis) Remove in libuv v2. */ \ uv__io_t async_io_watcher; \ int async_wfd; \ @@ -258,7 +259,7 @@ typedef struct { #define UV_PRIVATE_REQ_TYPES /* empty */ #define UV_WRITE_PRIVATE_FIELDS \ - struct uv__queue queue; \ + void* queue[2]; \ unsigned int write_index; \ uv_buf_t* bufs; \ unsigned int nbufs; \ @@ -266,12 +267,12 @@ typedef struct { uv_buf_t bufsml[4]; \ #define UV_CONNECT_PRIVATE_FIELDS \ - struct uv__queue queue; \ + void* queue[2]; \ #define UV_SHUTDOWN_PRIVATE_FIELDS /* empty */ #define UV_UDP_SEND_PRIVATE_FIELDS \ - struct uv__queue queue; \ + void* queue[2]; \ struct sockaddr_storage addr; \ unsigned int nbufs; \ uv_buf_t* bufs; \ @@ -287,8 +288,8 @@ typedef struct { uv_connect_t *connect_req; \ uv_shutdown_t *shutdown_req; \ uv__io_t io_watcher; \ - struct uv__queue write_queue; \ - struct uv__queue write_completed_queue; \ + void* write_queue[2]; \ + void* write_completed_queue[2]; \ uv_connection_cb connection_cb; \ int delayed_error; \ int accepted_fd; \ @@ -301,38 +302,35 @@ typedef struct { uv_alloc_cb alloc_cb; \ uv_udp_recv_cb recv_cb; \ uv__io_t io_watcher; \ - struct uv__queue write_queue; \ - struct uv__queue write_completed_queue; \ + void* write_queue[2]; \ + void* write_completed_queue[2]; \ #define UV_PIPE_PRIVATE_FIELDS \ - const char* pipe_fname; /* NULL or strdup'ed */ + const char* pipe_fname; /* strdup'ed */ #define UV_POLL_PRIVATE_FIELDS \ uv__io_t io_watcher; #define UV_PREPARE_PRIVATE_FIELDS \ uv_prepare_cb prepare_cb; \ - struct uv__queue queue; \ + void* queue[2]; \ #define UV_CHECK_PRIVATE_FIELDS \ uv_check_cb check_cb; \ - struct uv__queue queue; \ + void* queue[2]; \ #define UV_IDLE_PRIVATE_FIELDS \ uv_idle_cb idle_cb; \ - struct uv__queue queue; \ + void* queue[2]; \ #define UV_ASYNC_PRIVATE_FIELDS \ uv_async_cb async_cb; \ - struct uv__queue queue; \ + void* queue[2]; \ int pending; \ #define UV_TIMER_PRIVATE_FIELDS \ uv_timer_cb timer_cb; \ - union { \ - void* heap[3]; \ - struct uv__queue queue; \ - } node; \ + void* heap_node[3]; \ uint64_t timeout; \ uint64_t repeat; \ uint64_t start_id; @@ -356,7 +354,7 @@ typedef struct { int retcode; #define UV_PROCESS_PRIVATE_FIELDS \ - struct uv__queue queue; \ + void* queue[2]; \ int status; \ #define UV_FS_PRIVATE_FIELDS \ @@ -421,8 +419,6 @@ typedef struct { # define UV_FS_O_DIRECT 0x04000 #elif defined(__linux__) && defined(__x86_64__) # define UV_FS_O_DIRECT 0x04000 -#elif defined(__linux__) && defined(__loongarch__) -# define UV_FS_O_DIRECT 0x04000 #elif defined(O_DIRECT) # define UV_FS_O_DIRECT O_DIRECT #else diff --git a/include/uv/version.h b/include/uv/version.h index d6a61a1..9c9d292 100644 --- a/include/uv/version.h +++ b/include/uv/version.h @@ -31,8 +31,8 @@ */ #define UV_VERSION_MAJOR 1 -#define UV_VERSION_MINOR 48 -#define UV_VERSION_PATCH 0 +#define UV_VERSION_MINOR 44 +#define UV_VERSION_PATCH 2 #define UV_VERSION_IS_RELEASE 1 #define UV_VERSION_SUFFIX "" diff --git a/include/uv/win.h b/include/uv/win.h index c1a9efd..9728665 100644 --- a/include/uv/win.h +++ b/include/uv/win.h @@ -45,7 +45,7 @@ typedef struct pollfd { #endif #include -/* Disable the typedef in mstcpip.h of MinGW. */ +// Disable the typedef in mstcpip.h of MinGW. #define _TCP_INITIAL_RTO_PARAMETERS _TCP_INITIAL_RTO_PARAMETERS__AVOID #define TCP_INITIAL_RTO_PARAMETERS TCP_INITIAL_RTO_PARAMETERS__AVOID #define PTCP_INITIAL_RTO_PARAMETERS PTCP_INITIAL_RTO_PARAMETERS__AVOID @@ -59,7 +59,12 @@ typedef struct pollfd { #include #include #include -#include + +#if defined(_MSC_VER) && _MSC_VER < 1600 +# include "uv/stdint-msvc2008.h" +#else +# include +#endif #include "uv/tree.h" #include "uv/threadpool.h" @@ -70,11 +75,6 @@ typedef struct pollfd { # define S_IFLNK 0xA000 #endif -/* Define missing in Windows Kit Include\{VERSION}\ucrt\sys\stat.h */ -#if defined(_CRT_INTERNAL_NONSTDC_NAMES) && _CRT_INTERNAL_NONSTDC_NAMES && !defined(S_IFIFO) -# define S_IFIFO _S_IFIFO -#endif - /* Additional signals supported by uv_signal and or uv_kill. The CRT defines * the following signals already: * @@ -91,7 +91,6 @@ typedef struct pollfd { * variants (Linux and Darwin) */ #define SIGHUP 1 -#define SIGQUIT 3 #define SIGKILL 9 #define SIGWINCH 28 @@ -275,12 +274,11 @@ typedef struct { } uv_rwlock_t; typedef struct { - unsigned threshold; - unsigned in; + unsigned int n; + unsigned int count; uv_mutex_t mutex; - /* TODO: in v2 make this a uv_cond_t, without unused_ */ - CONDITION_VARIABLE cond; - unsigned out; + uv_sem_t turnstile1; + uv_sem_t turnstile2; } uv_barrier_t; typedef struct { @@ -351,14 +349,14 @@ typedef struct { uv_idle_t* next_idle_handle; \ /* This handle holds the peer sockets for the fast variant of uv_poll_t */ \ SOCKET poll_peer_sockets[UV_MSAFD_PROVIDER_COUNT]; \ - /* No longer used. */ \ + /* Counter to keep track of active tcp streams */ \ unsigned int active_tcp_streams; \ - /* No longer used. */ \ + /* Counter to keep track of active udp streams */ \ unsigned int active_udp_streams; \ /* Counter to started timer */ \ uint64_t timer_counter; \ /* Threadpool */ \ - struct uv__queue wq; \ + void* wq[2]; \ uv_mutex_t wq_mutex; \ uv_async_t wq_async; @@ -385,7 +383,6 @@ typedef struct { ULONG_PTR result; /* overlapped.Internal is reused to hold the result */\ HANDLE pipeHandle; \ DWORD duplex_flags; \ - WCHAR* name; \ } connect; \ } u; \ struct uv_req_s* next_req; @@ -487,7 +484,7 @@ typedef struct { uint32_t payload_remaining; \ uint64_t dummy; /* TODO: retained for ABI compat; remove this in v2.x. */ \ } ipc_data_frame; \ - struct uv__queue ipc_xfer_queue; \ + void* ipc_xfer_queue[2]; \ int ipc_xfer_queue_length; \ uv_write_t* non_overlapped_writes_tail; \ CRITICAL_SECTION readfile_thread_lock; \ @@ -501,7 +498,7 @@ typedef struct { struct { uv_pipe_connection_fields } conn; \ } pipe; -/* TODO: put the parser states in a union - TTY handles are always half-duplex +/* TODO: put the parser states in an union - TTY handles are always half-duplex * so read-state can safely overlap write-state. */ #define UV_TTY_PRIVATE_FIELDS \ HANDLE handle; \ @@ -551,10 +548,7 @@ typedef struct { unsigned char events; #define UV_TIMER_PRIVATE_FIELDS \ - union { \ - void* heap[3]; \ - struct uv__queue queue; \ - } node; \ + void* heap_node[3]; \ int unused; \ uint64_t timeout; \ uint64_t repeat; \ @@ -612,7 +606,7 @@ typedef struct { struct uv_process_exit_s { \ UV_REQ_FIELDS \ } exit_req; \ - void* unused; /* TODO: retained for ABI compat; remove this in v2.x. */ \ + BYTE* child_stdio_buffer; \ int exit_signal; \ HANDLE wait_handle; \ HANDLE process_handle; \ diff --git a/libuv-static.pc.in b/libuv-static.pc.in index 639058c..ea62548 100644 --- a/libuv-static.pc.in +++ b/libuv-static.pc.in @@ -8,5 +8,5 @@ Version: @PACKAGE_VERSION@ Description: multi-platform support library with a focus on asynchronous I/O. URL: http://libuv.org/ -Libs: -L${libdir} -l:libuv.a @LIBS@ +Libs: -L${libdir} -luv_a @LIBS@ Cflags: -I${includedir} diff --git a/libuv.pc.in b/libuv.pc.in index 0f56914..1d7b86f 100644 --- a/libuv.pc.in +++ b/libuv.pc.in @@ -2,7 +2,6 @@ prefix=@prefix@ exec_prefix=${prefix} libdir=@libdir@ includedir=@includedir@ -LIBUV_STATIC=-L${libdir} -l:libuv.a @LIBS@ Name: libuv Version: @PACKAGE_VERSION@ diff --git a/m4/.gitignore b/m4/.gitignore deleted file mode 100644 index bb91e50..0000000 --- a/m4/.gitignore +++ /dev/null @@ -1,5 +0,0 @@ -# Ignore libtoolize-generated files. -*.m4 -!as_case.m4 -!ax_pthread.m4 -!libuv-check-flags.m4 diff --git a/m4/as_case.m4 b/m4/as_case.m4 deleted file mode 100644 index c7ae0f0..0000000 --- a/m4/as_case.m4 +++ /dev/null @@ -1,21 +0,0 @@ -# AS_CASE(WORD, [PATTERN1], [IF-MATCHED1]...[DEFAULT]) -# ---------------------------------------------------- -# Expand into -# | case WORD in -# | PATTERN1) IF-MATCHED1 ;; -# | ... -# | *) DEFAULT ;; -# | esac -m4_define([_AS_CASE], -[m4_if([$#], 0, [m4_fatal([$0: too few arguments: $#])], - [$#], 1, [ *) $1 ;;], - [$#], 2, [ $1) m4_default([$2], [:]) ;;], - [ $1) m4_default([$2], [:]) ;; -$0(m4_shiftn(2, $@))])dnl -]) -m4_defun([AS_CASE], -[m4_ifval([$2$3], -[case $1 in -_AS_CASE(m4_shift($@)) -esac])]) - diff --git a/m4/ax_pthread.m4 b/m4/ax_pthread.m4 deleted file mode 100644 index 5fbf9fe..0000000 --- a/m4/ax_pthread.m4 +++ /dev/null @@ -1,485 +0,0 @@ -# =========================================================================== -# https://www.gnu.org/software/autoconf-archive/ax_pthread.html -# =========================================================================== -# -# SYNOPSIS -# -# AX_PTHREAD([ACTION-IF-FOUND[, ACTION-IF-NOT-FOUND]]) -# -# DESCRIPTION -# -# This macro figures out how to build C programs using POSIX threads. It -# sets the PTHREAD_LIBS output variable to the threads library and linker -# flags, and the PTHREAD_CFLAGS output variable to any special C compiler -# flags that are needed. (The user can also force certain compiler -# flags/libs to be tested by setting these environment variables.) -# -# Also sets PTHREAD_CC to any special C compiler that is needed for -# multi-threaded programs (defaults to the value of CC otherwise). (This -# is necessary on AIX to use the special cc_r compiler alias.) -# -# NOTE: You are assumed to not only compile your program with these flags, -# but also to link with them as well. For example, you might link with -# $PTHREAD_CC $CFLAGS $PTHREAD_CFLAGS $LDFLAGS ... $PTHREAD_LIBS $LIBS -# -# If you are only building threaded programs, you may wish to use these -# variables in your default LIBS, CFLAGS, and CC: -# -# LIBS="$PTHREAD_LIBS $LIBS" -# CFLAGS="$CFLAGS $PTHREAD_CFLAGS" -# CC="$PTHREAD_CC" -# -# In addition, if the PTHREAD_CREATE_JOINABLE thread-attribute constant -# has a nonstandard name, this macro defines PTHREAD_CREATE_JOINABLE to -# that name (e.g. PTHREAD_CREATE_UNDETACHED on AIX). -# -# Also HAVE_PTHREAD_PRIO_INHERIT is defined if pthread is found and the -# PTHREAD_PRIO_INHERIT symbol is defined when compiling with -# PTHREAD_CFLAGS. -# -# ACTION-IF-FOUND is a list of shell commands to run if a threads library -# is found, and ACTION-IF-NOT-FOUND is a list of commands to run it if it -# is not found. If ACTION-IF-FOUND is not specified, the default action -# will define HAVE_PTHREAD. -# -# Please let the authors know if this macro fails on any platform, or if -# you have any other suggestions or comments. This macro was based on work -# by SGJ on autoconf scripts for FFTW (http://www.fftw.org/) (with help -# from M. Frigo), as well as ac_pthread and hb_pthread macros posted by -# Alejandro Forero Cuervo to the autoconf macro repository. We are also -# grateful for the helpful feedback of numerous users. -# -# Updated for Autoconf 2.68 by Daniel Richard G. -# -# LICENSE -# -# Copyright (c) 2008 Steven G. Johnson -# Copyright (c) 2011 Daniel Richard G. -# -# This program is free software: you can redistribute it and/or modify it -# under the terms of the GNU General Public License as published by the -# Free Software Foundation, either version 3 of the License, or (at your -# option) any later version. -# -# This program is distributed in the hope that it will be useful, but -# WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General -# Public License for more details. -# -# You should have received a copy of the GNU General Public License along -# with this program. If not, see . -# -# As a special exception, the respective Autoconf Macro's copyright owner -# gives unlimited permission to copy, distribute and modify the configure -# scripts that are the output of Autoconf when processing the Macro. You -# need not follow the terms of the GNU General Public License when using -# or distributing such scripts, even though portions of the text of the -# Macro appear in them. The GNU General Public License (GPL) does govern -# all other use of the material that constitutes the Autoconf Macro. -# -# This special exception to the GPL applies to versions of the Autoconf -# Macro released by the Autoconf Archive. When you make and distribute a -# modified version of the Autoconf Macro, you may extend this special -# exception to the GPL to apply to your modified version as well. - -#serial 24 - -AU_ALIAS([ACX_PTHREAD], [AX_PTHREAD]) -AC_DEFUN([AX_PTHREAD], [ -AC_REQUIRE([AC_CANONICAL_HOST]) -AC_REQUIRE([AC_PROG_CC]) -AC_REQUIRE([AC_PROG_SED]) -AC_LANG_PUSH([C]) -ax_pthread_ok=no - -# We used to check for pthread.h first, but this fails if pthread.h -# requires special compiler flags (e.g. on Tru64 or Sequent). -# It gets checked for in the link test anyway. - -# First of all, check if the user has set any of the PTHREAD_LIBS, -# etcetera environment variables, and if threads linking works using -# them: -if test "x$PTHREAD_CFLAGS$PTHREAD_LIBS" != "x"; then - ax_pthread_save_CC="$CC" - ax_pthread_save_CFLAGS="$CFLAGS" - ax_pthread_save_LIBS="$LIBS" - AS_IF([test "x$PTHREAD_CC" != "x"], [CC="$PTHREAD_CC"]) - CFLAGS="$CFLAGS $PTHREAD_CFLAGS" - LIBS="$PTHREAD_LIBS $LIBS" - AC_MSG_CHECKING([for pthread_join using $CC $PTHREAD_CFLAGS $PTHREAD_LIBS]) - AC_LINK_IFELSE([AC_LANG_CALL([], [pthread_join])], [ax_pthread_ok=yes]) - AC_MSG_RESULT([$ax_pthread_ok]) - if test "x$ax_pthread_ok" = "xno"; then - PTHREAD_LIBS="" - PTHREAD_CFLAGS="" - fi - CC="$ax_pthread_save_CC" - CFLAGS="$ax_pthread_save_CFLAGS" - LIBS="$ax_pthread_save_LIBS" -fi - -# We must check for the threads library under a number of different -# names; the ordering is very important because some systems -# (e.g. DEC) have both -lpthread and -lpthreads, where one of the -# libraries is broken (non-POSIX). - -# Create a list of thread flags to try. Items starting with a "-" are -# C compiler flags, and other items are library names, except for "none" -# which indicates that we try without any flags at all, and "pthread-config" -# which is a program returning the flags for the Pth emulation library. - -ax_pthread_flags="pthreads none -Kthread -pthread -pthreads -mthreads pthread --thread-safe -mt pthread-config" - -# The ordering *is* (sometimes) important. Some notes on the -# individual items follow: - -# pthreads: AIX (must check this before -lpthread) -# none: in case threads are in libc; should be tried before -Kthread and -# other compiler flags to prevent continual compiler warnings -# -Kthread: Sequent (threads in libc, but -Kthread needed for pthread.h) -# -pthread: Linux/gcc (kernel threads), BSD/gcc (userland threads), Tru64 -# (Note: HP C rejects this with "bad form for `-t' option") -# -pthreads: Solaris/gcc (Note: HP C also rejects) -# -mt: Sun Workshop C (may only link SunOS threads [-lthread], but it -# doesn't hurt to check since this sometimes defines pthreads and -# -D_REENTRANT too), HP C (must be checked before -lpthread, which -# is present but should not be used directly; and before -mthreads, -# because the compiler interprets this as "-mt" + "-hreads") -# -mthreads: Mingw32/gcc, Lynx/gcc -# pthread: Linux, etcetera -# --thread-safe: KAI C++ -# pthread-config: use pthread-config program (for GNU Pth library) - -case $host_os in - - freebsd*) - - # -kthread: FreeBSD kernel threads (preferred to -pthread since SMP-able) - # lthread: LinuxThreads port on FreeBSD (also preferred to -pthread) - - ax_pthread_flags="-kthread lthread $ax_pthread_flags" - ;; - - hpux*) - - # From the cc(1) man page: "[-mt] Sets various -D flags to enable - # multi-threading and also sets -lpthread." - - ax_pthread_flags="-mt -pthread pthread $ax_pthread_flags" - ;; - - openedition*) - - # IBM z/OS requires a feature-test macro to be defined in order to - # enable POSIX threads at all, so give the user a hint if this is - # not set. (We don't define these ourselves, as they can affect - # other portions of the system API in unpredictable ways.) - - AC_EGREP_CPP([AX_PTHREAD_ZOS_MISSING], - [ -# if !defined(_OPEN_THREADS) && !defined(_UNIX03_THREADS) - AX_PTHREAD_ZOS_MISSING -# endif - ], - [AC_MSG_WARN([IBM z/OS requires -D_OPEN_THREADS or -D_UNIX03_THREADS to enable pthreads support.])]) - ;; - - solaris*) - - # On Solaris (at least, for some versions), libc contains stubbed - # (non-functional) versions of the pthreads routines, so link-based - # tests will erroneously succeed. (N.B.: The stubs are missing - # pthread_cleanup_push, or rather a function called by this macro, - # so we could check for that, but who knows whether they'll stub - # that too in a future libc.) So we'll check first for the - # standard Solaris way of linking pthreads (-mt -lpthread). - - ax_pthread_flags="-mt,pthread pthread $ax_pthread_flags" - ;; -esac - -# GCC generally uses -pthread, or -pthreads on some platforms (e.g. SPARC) - -AS_IF([test "x$GCC" = "xyes"], - [ax_pthread_flags="-pthread -pthreads $ax_pthread_flags"]) - -# The presence of a feature test macro requesting re-entrant function -# definitions is, on some systems, a strong hint that pthreads support is -# correctly enabled - -case $host_os in - darwin* | hpux* | linux* | osf* | solaris*) - ax_pthread_check_macro="_REENTRANT" - ;; - - aix*) - ax_pthread_check_macro="_THREAD_SAFE" - ;; - - *) - ax_pthread_check_macro="--" - ;; -esac -AS_IF([test "x$ax_pthread_check_macro" = "x--"], - [ax_pthread_check_cond=0], - [ax_pthread_check_cond="!defined($ax_pthread_check_macro)"]) - -# Are we compiling with Clang? - -AC_CACHE_CHECK([whether $CC is Clang], - [ax_cv_PTHREAD_CLANG], - [ax_cv_PTHREAD_CLANG=no - # Note that Autoconf sets GCC=yes for Clang as well as GCC - if test "x$GCC" = "xyes"; then - AC_EGREP_CPP([AX_PTHREAD_CC_IS_CLANG], - [/* Note: Clang 2.7 lacks __clang_[a-z]+__ */ -# if defined(__clang__) && defined(__llvm__) - AX_PTHREAD_CC_IS_CLANG -# endif - ], - [ax_cv_PTHREAD_CLANG=yes]) - fi - ]) -ax_pthread_clang="$ax_cv_PTHREAD_CLANG" - -ax_pthread_clang_warning=no - -# Clang needs special handling, because older versions handle the -pthread -# option in a rather... idiosyncratic way - -if test "x$ax_pthread_clang" = "xyes"; then - - # Clang takes -pthread; it has never supported any other flag - - # (Note 1: This will need to be revisited if a system that Clang - # supports has POSIX threads in a separate library. This tends not - # to be the way of modern systems, but it's conceivable.) - - # (Note 2: On some systems, notably Darwin, -pthread is not needed - # to get POSIX threads support; the API is always present and - # active. We could reasonably leave PTHREAD_CFLAGS empty. But - # -pthread does define _REENTRANT, and while the Darwin headers - # ignore this macro, third-party headers might not.) - - PTHREAD_CFLAGS="-pthread" - PTHREAD_LIBS= - - ax_pthread_ok=yes - - # However, older versions of Clang make a point of warning the user - # that, in an invocation where only linking and no compilation is - # taking place, the -pthread option has no effect ("argument unused - # during compilation"). They expect -pthread to be passed in only - # when source code is being compiled. - # - # Problem is, this is at odds with the way Automake and most other - # C build frameworks function, which is that the same flags used in - # compilation (CFLAGS) are also used in linking. Many systems - # supported by AX_PTHREAD require exactly this for POSIX threads - # support, and in fact it is often not straightforward to specify a - # flag that is used only in the compilation phase and not in - # linking. Such a scenario is extremely rare in practice. - # - # Even though use of the -pthread flag in linking would only print - # a warning, this can be a nuisance for well-run software projects - # that build with -Werror. So if the active version of Clang has - # this misfeature, we search for an option to squash it. - - AC_CACHE_CHECK([whether Clang needs flag to prevent "argument unused" warning when linking with -pthread], - [ax_cv_PTHREAD_CLANG_NO_WARN_FLAG], - [ax_cv_PTHREAD_CLANG_NO_WARN_FLAG=unknown - # Create an alternate version of $ac_link that compiles and - # links in two steps (.c -> .o, .o -> exe) instead of one - # (.c -> exe), because the warning occurs only in the second - # step - ax_pthread_save_ac_link="$ac_link" - ax_pthread_sed='s/conftest\.\$ac_ext/conftest.$ac_objext/g' - ax_pthread_link_step=`$as_echo "$ac_link" | sed "$ax_pthread_sed"` - ax_pthread_2step_ac_link="($ac_compile) && (echo ==== >&5) && ($ax_pthread_link_step)" - ax_pthread_save_CFLAGS="$CFLAGS" - for ax_pthread_try in '' -Qunused-arguments -Wno-unused-command-line-argument unknown; do - AS_IF([test "x$ax_pthread_try" = "xunknown"], [break]) - CFLAGS="-Werror -Wunknown-warning-option $ax_pthread_try -pthread $ax_pthread_save_CFLAGS" - ac_link="$ax_pthread_save_ac_link" - AC_LINK_IFELSE([AC_LANG_SOURCE([[int main(void){return 0;}]])], - [ac_link="$ax_pthread_2step_ac_link" - AC_LINK_IFELSE([AC_LANG_SOURCE([[int main(void){return 0;}]])], - [break]) - ]) - done - ac_link="$ax_pthread_save_ac_link" - CFLAGS="$ax_pthread_save_CFLAGS" - AS_IF([test "x$ax_pthread_try" = "x"], [ax_pthread_try=no]) - ax_cv_PTHREAD_CLANG_NO_WARN_FLAG="$ax_pthread_try" - ]) - - case "$ax_cv_PTHREAD_CLANG_NO_WARN_FLAG" in - no | unknown) ;; - *) PTHREAD_CFLAGS="$ax_cv_PTHREAD_CLANG_NO_WARN_FLAG $PTHREAD_CFLAGS" ;; - esac - -fi # $ax_pthread_clang = yes - -if test "x$ax_pthread_ok" = "xno"; then -for ax_pthread_try_flag in $ax_pthread_flags; do - - case $ax_pthread_try_flag in - none) - AC_MSG_CHECKING([whether pthreads work without any flags]) - ;; - - -mt,pthread) - AC_MSG_CHECKING([whether pthreads work with -mt -lpthread]) - PTHREAD_CFLAGS="-mt" - PTHREAD_LIBS="-lpthread" - ;; - - -*) - AC_MSG_CHECKING([whether pthreads work with $ax_pthread_try_flag]) - PTHREAD_CFLAGS="$ax_pthread_try_flag" - ;; - - pthread-config) - AC_CHECK_PROG([ax_pthread_config], [pthread-config], [yes], [no]) - AS_IF([test "x$ax_pthread_config" = "xno"], [continue]) - PTHREAD_CFLAGS="`pthread-config --cflags`" - PTHREAD_LIBS="`pthread-config --ldflags` `pthread-config --libs`" - ;; - - *) - AC_MSG_CHECKING([for the pthreads library -l$ax_pthread_try_flag]) - PTHREAD_LIBS="-l$ax_pthread_try_flag" - ;; - esac - - ax_pthread_save_CFLAGS="$CFLAGS" - ax_pthread_save_LIBS="$LIBS" - CFLAGS="$CFLAGS $PTHREAD_CFLAGS" - LIBS="$PTHREAD_LIBS $LIBS" - - # Check for various functions. We must include pthread.h, - # since some functions may be macros. (On the Sequent, we - # need a special flag -Kthread to make this header compile.) - # We check for pthread_join because it is in -lpthread on IRIX - # while pthread_create is in libc. We check for pthread_attr_init - # due to DEC craziness with -lpthreads. We check for - # pthread_cleanup_push because it is one of the few pthread - # functions on Solaris that doesn't have a non-functional libc stub. - # We try pthread_create on general principles. - - AC_LINK_IFELSE([AC_LANG_PROGRAM([#include -# if $ax_pthread_check_cond -# error "$ax_pthread_check_macro must be defined" -# endif - static void routine(void *a) { a = 0; } - static void *start_routine(void *a) { return a; }], - [pthread_t th; pthread_attr_t attr; - pthread_create(&th, 0, start_routine, 0); - pthread_join(th, 0); - pthread_attr_init(&attr); - pthread_cleanup_push(routine, 0); - pthread_cleanup_pop(0) /* ; */])], - [ax_pthread_ok=yes], - []) - - CFLAGS="$ax_pthread_save_CFLAGS" - LIBS="$ax_pthread_save_LIBS" - - AC_MSG_RESULT([$ax_pthread_ok]) - AS_IF([test "x$ax_pthread_ok" = "xyes"], [break]) - - PTHREAD_LIBS="" - PTHREAD_CFLAGS="" -done -fi - -# Various other checks: -if test "x$ax_pthread_ok" = "xyes"; then - ax_pthread_save_CFLAGS="$CFLAGS" - ax_pthread_save_LIBS="$LIBS" - CFLAGS="$CFLAGS $PTHREAD_CFLAGS" - LIBS="$PTHREAD_LIBS $LIBS" - - # Detect AIX lossage: JOINABLE attribute is called UNDETACHED. - AC_CACHE_CHECK([for joinable pthread attribute], - [ax_cv_PTHREAD_JOINABLE_ATTR], - [ax_cv_PTHREAD_JOINABLE_ATTR=unknown - for ax_pthread_attr in PTHREAD_CREATE_JOINABLE PTHREAD_CREATE_UNDETACHED; do - AC_LINK_IFELSE([AC_LANG_PROGRAM([#include ], - [int attr = $ax_pthread_attr; return attr /* ; */])], - [ax_cv_PTHREAD_JOINABLE_ATTR=$ax_pthread_attr; break], - []) - done - ]) - AS_IF([test "x$ax_cv_PTHREAD_JOINABLE_ATTR" != "xunknown" && \ - test "x$ax_cv_PTHREAD_JOINABLE_ATTR" != "xPTHREAD_CREATE_JOINABLE" && \ - test "x$ax_pthread_joinable_attr_defined" != "xyes"], - [AC_DEFINE_UNQUOTED([PTHREAD_CREATE_JOINABLE], - [$ax_cv_PTHREAD_JOINABLE_ATTR], - [Define to necessary symbol if this constant - uses a non-standard name on your system.]) - ax_pthread_joinable_attr_defined=yes - ]) - - AC_CACHE_CHECK([whether more special flags are required for pthreads], - [ax_cv_PTHREAD_SPECIAL_FLAGS], - [ax_cv_PTHREAD_SPECIAL_FLAGS=no - case $host_os in - solaris*) - ax_cv_PTHREAD_SPECIAL_FLAGS="-D_POSIX_PTHREAD_SEMANTICS" - ;; - esac - ]) - AS_IF([test "x$ax_cv_PTHREAD_SPECIAL_FLAGS" != "xno" && \ - test "x$ax_pthread_special_flags_added" != "xyes"], - [PTHREAD_CFLAGS="$ax_cv_PTHREAD_SPECIAL_FLAGS $PTHREAD_CFLAGS" - ax_pthread_special_flags_added=yes]) - - AC_CACHE_CHECK([for PTHREAD_PRIO_INHERIT], - [ax_cv_PTHREAD_PRIO_INHERIT], - [AC_LINK_IFELSE([AC_LANG_PROGRAM([[#include ]], - [[int i = PTHREAD_PRIO_INHERIT;]])], - [ax_cv_PTHREAD_PRIO_INHERIT=yes], - [ax_cv_PTHREAD_PRIO_INHERIT=no]) - ]) - AS_IF([test "x$ax_cv_PTHREAD_PRIO_INHERIT" = "xyes" && \ - test "x$ax_pthread_prio_inherit_defined" != "xyes"], - [AC_DEFINE([HAVE_PTHREAD_PRIO_INHERIT], [1], [Have PTHREAD_PRIO_INHERIT.]) - ax_pthread_prio_inherit_defined=yes - ]) - - CFLAGS="$ax_pthread_save_CFLAGS" - LIBS="$ax_pthread_save_LIBS" - - # More AIX lossage: compile with *_r variant - if test "x$GCC" != "xyes"; then - case $host_os in - aix*) - AS_CASE(["x/$CC"], - [x*/c89|x*/c89_128|x*/c99|x*/c99_128|x*/cc|x*/cc128|x*/xlc|x*/xlc_v6|x*/xlc128|x*/xlc128_v6], - [#handle absolute path differently from PATH based program lookup - AS_CASE(["x$CC"], - [x/*], - [AS_IF([AS_EXECUTABLE_P([${CC}_r])],[PTHREAD_CC="${CC}_r"])], - [AC_CHECK_PROGS([PTHREAD_CC],[${CC}_r],[$CC])])]) - ;; - esac - fi -fi - -test -n "$PTHREAD_CC" || PTHREAD_CC="$CC" - -AC_SUBST([PTHREAD_LIBS]) -AC_SUBST([PTHREAD_CFLAGS]) -AC_SUBST([PTHREAD_CC]) - -# Finally, execute ACTION-IF-FOUND/ACTION-IF-NOT-FOUND: -if test "x$ax_pthread_ok" = "xyes"; then - ifelse([$1],,[AC_DEFINE([HAVE_PTHREAD],[1],[Define if you have POSIX threads libraries and header files.])],[$1]) - : -else - ax_pthread_ok=no - $2 -fi -AC_LANG_POP -])dnl AX_PTHREAD diff --git a/m4/libuv-check-flags.m4 b/m4/libuv-check-flags.m4 deleted file mode 100644 index 2a01308..0000000 --- a/m4/libuv-check-flags.m4 +++ /dev/null @@ -1,336 +0,0 @@ -dnl Macros to check the presence of generic (non-typed) symbols. -dnl Copyright (c) 2006-2008 Diego Pettenò -dnl Copyright (c) 2006-2008 xine project -dnl Copyright (c) 2021 libuv project -dnl -dnl This program is free software; you can redistribute it and/or modify -dnl it under the terms of the GNU General Public License as published by -dnl the Free Software Foundation; either version 3, or (at your option) -dnl any later version. -dnl -dnl This program is distributed in the hope that it will be useful, -dnl but WITHOUT ANY WARRANTY; without even the implied warranty of -dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -dnl GNU General Public License for more details. -dnl -dnl You should have received a copy of the GNU General Public License -dnl along with this program; if not, write to the Free Software -dnl Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA -dnl 02110-1301, USA. -dnl -dnl As a special exception, the copyright owners of the -dnl macro gives unlimited permission to copy, distribute and modify the -dnl configure scripts that are the output of Autoconf when processing the -dnl Macro. You need not follow the terms of the GNU General Public -dnl License when using or distributing such scripts, even though portions -dnl of the text of the Macro appear in them. The GNU General Public -dnl License (GPL) does govern all other use of the material that -dnl constitutes the Autoconf Macro. -dnl -dnl This special exception to the GPL applies to versions of the -dnl Autoconf Macro released by this project. When you make and -dnl distribute a modified version of the Autoconf Macro, you may extend -dnl this special exception to the GPL to apply to your modified version as -dnl well. - -dnl Check if the flag is supported by compiler -dnl CC_CHECK_CFLAGS_SILENT([FLAG], [ACTION-IF-FOUND],[ACTION-IF-NOT-FOUND]) - -AC_DEFUN([CC_CHECK_CFLAGS_SILENT], [ - AC_CACHE_VAL(AS_TR_SH([cc_cv_cflags_$1]), - [ac_save_CFLAGS="$CFLAGS" - CFLAGS="$CFLAGS $1" - AC_COMPILE_IFELSE([AC_LANG_SOURCE([int a;])], - [eval "AS_TR_SH([cc_cv_cflags_$1])='yes'"], - [eval "AS_TR_SH([cc_cv_cflags_$1])='no'"]) - CFLAGS="$ac_save_CFLAGS" - ]) - - AS_IF([eval test x$]AS_TR_SH([cc_cv_cflags_$1])[ = xyes], - [$2], [$3]) -]) - -dnl Check if the flag is supported by compiler (cacheable) -dnl CC_CHECK_CFLAGS([FLAG], [ACTION-IF-FOUND],[ACTION-IF-NOT-FOUND]) - -AC_DEFUN([CC_CHECK_CFLAGS], [ - AC_CACHE_CHECK([if $CC supports $1 flag], - AS_TR_SH([cc_cv_cflags_$1]), - CC_CHECK_CFLAGS_SILENT([$1]) dnl Don't execute actions here! - ) - - AS_IF([eval test x$]AS_TR_SH([cc_cv_cflags_$1])[ = xyes], - [$2], [$3]) -]) - -dnl CC_CHECK_CFLAG_APPEND(FLAG, [action-if-found], [action-if-not-found]) -dnl Check for CFLAG and appends them to AM_CFLAGS if supported -AC_DEFUN([CC_CHECK_CFLAG_APPEND], [ - AC_CACHE_CHECK([if $CC supports $1 flag], - AS_TR_SH([cc_cv_cflags_$1]), - CC_CHECK_CFLAGS_SILENT([$1]) dnl Don't execute actions here! - ) - - AS_IF([eval test x$]AS_TR_SH([cc_cv_cflags_$1])[ = xyes], - [AM_CFLAGS="$AM_CFLAGS $1"; DEBUG_CFLAGS="$DEBUG_CFLAGS $1"; $2], [$3]) - - AC_SUBST([AM_CFLAGS]) -]) - -dnl CC_CHECK_CFLAGS_APPEND([FLAG1 FLAG2], [action-if-found], [action-if-not]) -AC_DEFUN([CC_CHECK_CFLAGS_APPEND], [ - for flag in $1; do - CC_CHECK_CFLAG_APPEND($flag, [$2], [$3]) - done -]) - -dnl Check if the flag is supported by linker (cacheable) -dnl CC_CHECK_LDFLAGS([FLAG], [ACTION-IF-FOUND],[ACTION-IF-NOT-FOUND]) - -AC_DEFUN([CC_CHECK_LDFLAGS], [ - AC_CACHE_CHECK([if $CC supports $1 flag], - AS_TR_SH([cc_cv_ldflags_$1]), - [ac_save_LDFLAGS="$LDFLAGS" - LDFLAGS="$LDFLAGS $1" - AC_LANG_PUSH([C]) - AC_LINK_IFELSE([AC_LANG_SOURCE([int main() { return 1; }])], - [eval "AS_TR_SH([cc_cv_ldflags_$1])='yes'"], - [eval "AS_TR_SH([cc_cv_ldflags_$1])="]) - AC_LANG_POP([C]) - LDFLAGS="$ac_save_LDFLAGS" - ]) - - AS_IF([eval test x$]AS_TR_SH([cc_cv_ldflags_$1])[ = xyes], - [$2], [$3]) -]) - -dnl Check if flag is supported by both compiler and linker -dnl If so, append it to AM_CFLAGS -dnl CC_CHECK_FLAG_SUPPORTED_APPEND([FLAG]) - -AC_DEFUN([CC_CHECK_FLAG_SUPPORTED_APPEND], [ - CC_CHECK_CFLAGS([$1], - [CC_CHECK_LDFLAGS([$1], - [AM_CFLAGS="$AM_CFLAGS $1"; - DEBUG_CFLAGS="$DEBUG_CFLAGS $1"; - AC_SUBST([AM_CFLAGS]) - ]) - ]) -]) - -dnl define the LDFLAGS_NOUNDEFINED variable with the correct value for -dnl the current linker to avoid undefined references in a shared object. -AC_DEFUN([CC_NOUNDEFINED], [ - dnl We check $host for which systems to enable this for. - AC_REQUIRE([AC_CANONICAL_HOST]) - - case $host in - dnl FreeBSD (et al.) does not complete linking for shared objects when pthreads - dnl are requested, as different implementations are present; to avoid problems - dnl use -Wl,-z,defs only for those platform not behaving this way. - *-freebsd* | *-openbsd*) ;; - *) - dnl First of all check for the --no-undefined variant of GNU ld. This allows - dnl for a much more readable commandline, so that people can understand what - dnl it does without going to look for what the heck -z defs does. - for possible_flags in "-Wl,--no-undefined" "-Wl,-z,defs"; do - CC_CHECK_LDFLAGS([$possible_flags], [LDFLAGS_NOUNDEFINED="$possible_flags"]) - break - done - ;; - esac - - AC_SUBST([LDFLAGS_NOUNDEFINED]) -]) - -dnl Check for a -Werror flag or equivalent. -Werror is the GCC -dnl and ICC flag that tells the compiler to treat all the warnings -dnl as fatal. We usually need this option to make sure that some -dnl constructs (like attributes) are not simply ignored. -dnl -dnl Other compilers don't support -Werror per se, but they support -dnl an equivalent flag: -dnl - Sun Studio compiler supports -errwarn=%all -AC_DEFUN([CC_CHECK_WERROR], [ - AC_CACHE_CHECK( - [for $CC way to treat warnings as errors], - [cc_cv_werror], - [CC_CHECK_CFLAGS_SILENT([-Werror], [cc_cv_werror=-Werror], - [CC_CHECK_CFLAGS_SILENT([-errwarn=%all], [cc_cv_werror=-errwarn=%all])]) - ]) -]) - -AC_DEFUN([CC_CHECK_ATTRIBUTE], [ - AC_REQUIRE([CC_CHECK_WERROR]) - AC_CACHE_CHECK([if $CC supports __attribute__(( ifelse([$2], , [$1], [$2]) ))], - AS_TR_SH([cc_cv_attribute_$1]), - [ac_save_CFLAGS="$CFLAGS" - CFLAGS="$CFLAGS $cc_cv_werror" - AC_LANG_PUSH([C]) - AC_COMPILE_IFELSE([AC_LANG_SOURCE([$3])], - [eval "AS_TR_SH([cc_cv_attribute_$1])='yes'"], - [eval "AS_TR_SH([cc_cv_attribute_$1])='no'"]) - AC_LANG_POP([C]) - CFLAGS="$ac_save_CFLAGS" - ]) - - AS_IF([eval test x$]AS_TR_SH([cc_cv_attribute_$1])[ = xyes], - [AC_DEFINE( - AS_TR_CPP([SUPPORT_ATTRIBUTE_$1]), 1, - [Define this if the compiler supports __attribute__(( ifelse([$2], , [$1], [$2]) ))] - ) - $4], - [$5]) -]) - -AC_DEFUN([CC_ATTRIBUTE_CONSTRUCTOR], [ - CC_CHECK_ATTRIBUTE( - [constructor],, - [void __attribute__((constructor)) ctor() { int a; }], - [$1], [$2]) -]) - -AC_DEFUN([CC_ATTRIBUTE_FORMAT], [ - CC_CHECK_ATTRIBUTE( - [format], [format(printf, n, n)], - [void __attribute__((format(printf, 1, 2))) printflike(const char *fmt, ...) { fmt = (void *)0; }], - [$1], [$2]) -]) - -AC_DEFUN([CC_ATTRIBUTE_FORMAT_ARG], [ - CC_CHECK_ATTRIBUTE( - [format_arg], [format_arg(printf)], - [char *__attribute__((format_arg(1))) gettextlike(const char *fmt) { fmt = (void *)0; }], - [$1], [$2]) -]) - -AC_DEFUN([CC_ATTRIBUTE_VISIBILITY], [ - CC_CHECK_ATTRIBUTE( - [visibility_$1], [visibility("$1")], - [void __attribute__((visibility("$1"))) $1_function() { }], - [$2], [$3]) -]) - -AC_DEFUN([CC_ATTRIBUTE_NONNULL], [ - CC_CHECK_ATTRIBUTE( - [nonnull], [nonnull()], - [void __attribute__((nonnull())) some_function(void *foo, void *bar) { foo = (void*)0; bar = (void*)0; }], - [$1], [$2]) -]) - -AC_DEFUN([CC_ATTRIBUTE_UNUSED], [ - CC_CHECK_ATTRIBUTE( - [unused], , - [void some_function(void *foo, __attribute__((unused)) void *bar);], - [$1], [$2]) -]) - -AC_DEFUN([CC_ATTRIBUTE_SENTINEL], [ - CC_CHECK_ATTRIBUTE( - [sentinel], , - [void some_function(void *foo, ...) __attribute__((sentinel));], - [$1], [$2]) -]) - -AC_DEFUN([CC_ATTRIBUTE_DEPRECATED], [ - CC_CHECK_ATTRIBUTE( - [deprecated], , - [void some_function(void *foo, ...) __attribute__((deprecated));], - [$1], [$2]) -]) - -AC_DEFUN([CC_ATTRIBUTE_ALIAS], [ - CC_CHECK_ATTRIBUTE( - [alias], [weak, alias], - [void other_function(void *foo) { } - void some_function(void *foo) __attribute__((weak, alias("other_function")));], - [$1], [$2]) -]) - -AC_DEFUN([CC_ATTRIBUTE_MALLOC], [ - CC_CHECK_ATTRIBUTE( - [malloc], , - [void * __attribute__((malloc)) my_alloc(int n);], - [$1], [$2]) -]) - -AC_DEFUN([CC_ATTRIBUTE_PACKED], [ - CC_CHECK_ATTRIBUTE( - [packed], , - [struct astructure { char a; int b; long c; void *d; } __attribute__((packed));], - [$1], [$2]) -]) - -AC_DEFUN([CC_ATTRIBUTE_CONST], [ - CC_CHECK_ATTRIBUTE( - [const], , - [int __attribute__((const)) twopow(int n) { return 1 << n; } ], - [$1], [$2]) -]) - -AC_DEFUN([CC_FLAG_VISIBILITY], [ - AC_REQUIRE([CC_CHECK_WERROR]) - AC_CACHE_CHECK([if $CC supports -fvisibility=hidden], - [cc_cv_flag_visibility], - [cc_flag_visibility_save_CFLAGS="$CFLAGS" - CFLAGS="$CFLAGS $cc_cv_werror" - CC_CHECK_CFLAGS_SILENT([-fvisibility=hidden], - cc_cv_flag_visibility='yes', - cc_cv_flag_visibility='no') - CFLAGS="$cc_flag_visibility_save_CFLAGS"]) - - AS_IF([test "x$cc_cv_flag_visibility" = "xyes"], - [AC_DEFINE([SUPPORT_FLAG_VISIBILITY], 1, - [Define this if the compiler supports the -fvisibility flag]) - $1], - [$2]) -]) - -AC_DEFUN([CC_FUNC_EXPECT], [ - AC_REQUIRE([CC_CHECK_WERROR]) - AC_CACHE_CHECK([if compiler has __builtin_expect function], - [cc_cv_func_expect], - [ac_save_CFLAGS="$CFLAGS" - CFLAGS="$CFLAGS $cc_cv_werror" - AC_LANG_PUSH([C]) - AC_COMPILE_IFELSE([AC_LANG_SOURCE( - [int some_function() { - int a = 3; - return (int)__builtin_expect(a, 3); - }])], - [cc_cv_func_expect=yes], - [cc_cv_func_expect=no]) - AC_LANG_POP([C]) - CFLAGS="$ac_save_CFLAGS" - ]) - - AS_IF([test "x$cc_cv_func_expect" = "xyes"], - [AC_DEFINE([SUPPORT__BUILTIN_EXPECT], 1, - [Define this if the compiler supports __builtin_expect() function]) - $1], - [$2]) -]) - -AC_DEFUN([CC_ATTRIBUTE_ALIGNED], [ - AC_REQUIRE([CC_CHECK_WERROR]) - AC_CACHE_CHECK([highest __attribute__ ((aligned ())) supported], - [cc_cv_attribute_aligned], - [ac_save_CFLAGS="$CFLAGS" - CFLAGS="$CFLAGS $cc_cv_werror" - AC_LANG_PUSH([C]) - for cc_attribute_align_try in 64 32 16 8 4 2; do - AC_COMPILE_IFELSE([AC_LANG_SOURCE([ - int main() { - static char c __attribute__ ((aligned($cc_attribute_align_try))) = 0; - return c; - }])], [cc_cv_attribute_aligned=$cc_attribute_align_try; break]) - done - AC_LANG_POP([C]) - CFLAGS="$ac_save_CFLAGS" - ]) - - if test "x$cc_cv_attribute_aligned" != "x"; then - AC_DEFINE_UNQUOTED([ATTRIBUTE_ALIGNED_MAX], [$cc_cv_attribute_aligned], - [Define the highest alignment supported]) - fi -]) diff --git a/src/idna.c b/src/idna.c index efc5f28..858b19d 100644 --- a/src/idna.c +++ b/src/idna.c @@ -1,4 +1,4 @@ -/* Copyright libuv contributors. All rights reserved. +/* Copyright (c) 2011, 2018 Ben Noordhuis * * Permission to use, copy, modify, and/or distribute this software for any * purpose with or without fee is hereby granted, provided that the above @@ -18,56 +18,11 @@ */ #include "uv.h" -#include "uv-common.h" #include "idna.h" #include #include #include /* UINT_MAX */ - -static int32_t uv__wtf8_decode1(const char** input) { - uint32_t code_point; - uint8_t b1; - uint8_t b2; - uint8_t b3; - uint8_t b4; - - b1 = **input; - if (b1 <= 0x7F) - return b1; /* ASCII code point */ - if (b1 < 0xC2) - return -1; /* invalid: continuation byte */ - code_point = b1; - - b2 = *++*input; - if ((b2 & 0xC0) != 0x80) - return -1; /* invalid: not a continuation byte */ - code_point = (code_point << 6) | (b2 & 0x3F); - if (b1 <= 0xDF) - return 0x7FF & code_point; /* two-byte character */ - - b3 = *++*input; - if ((b3 & 0xC0) != 0x80) - return -1; /* invalid: not a continuation byte */ - code_point = (code_point << 6) | (b3 & 0x3F); - if (b1 <= 0xEF) - return 0xFFFF & code_point; /* three-byte character */ - - b4 = *++*input; - if ((b4 & 0xC0) != 0x80) - return -1; /* invalid: not a continuation byte */ - code_point = (code_point << 6) | (b4 & 0x3F); - if (b1 <= 0xF4) { - code_point &= 0x1FFFFF; - if (code_point <= 0x10FFFF) - return code_point; /* four-byte character */ - } - - /* code point too large */ - return -1; -} - - static unsigned uv__utf8_decode1_slow(const char** p, const char* pe, unsigned a) { @@ -134,7 +89,6 @@ static unsigned uv__utf8_decode1_slow(const char** p, return a; } - unsigned uv__utf8_decode1(const char** p, const char* pe) { unsigned a; @@ -148,7 +102,6 @@ unsigned uv__utf8_decode1(const char** p, const char* pe) { return uv__utf8_decode1_slow(p, pe, a); } - static int uv__idna_toascii_label(const char* s, const char* se, char** d, char* de) { static const char alphabet[] = "abcdefghijklmnopqrstuvwxyz0123456789"; @@ -314,8 +267,7 @@ static int uv__idna_toascii_label(const char* s, const char* se, return 0; } - -ssize_t uv__idna_toascii(const char* s, const char* se, char* d, char* de) { +long uv__idna_toascii(const char* s, const char* se, char* d, char* de) { const char* si; const char* st; unsigned c; @@ -365,196 +317,3 @@ ssize_t uv__idna_toascii(const char* s, const char* se, char* d, char* de) { *d++ = '\0'; return d - ds; /* Number of bytes written. */ } - - -ssize_t uv_wtf8_length_as_utf16(const char* source_ptr) { - size_t w_target_len = 0; - int32_t code_point; - - do { - code_point = uv__wtf8_decode1(&source_ptr); - if (code_point < 0) - return -1; - if (code_point > 0xFFFF) - w_target_len++; - w_target_len++; - } while (*source_ptr++); - - return w_target_len; -} - - -void uv_wtf8_to_utf16(const char* source_ptr, - uint16_t* w_target, - size_t w_target_len) { - int32_t code_point; - - do { - code_point = uv__wtf8_decode1(&source_ptr); - /* uv_wtf8_length_as_utf16 should have been called and checked first. */ - assert(code_point >= 0); - if (code_point > 0x10000) { - assert(code_point < 0x10FFFF); - *w_target++ = (((code_point - 0x10000) >> 10) + 0xD800); - *w_target++ = ((code_point - 0x10000) & 0x3FF) + 0xDC00; - w_target_len -= 2; - } else { - *w_target++ = code_point; - w_target_len -= 1; - } - } while (*source_ptr++); - - (void)w_target_len; - assert(w_target_len == 0); -} - - -static int32_t uv__get_surrogate_value(const uint16_t* w_source_ptr, - ssize_t w_source_len) { - uint16_t u; - uint16_t next; - - u = w_source_ptr[0]; - if (u >= 0xD800 && u <= 0xDBFF && w_source_len != 1) { - next = w_source_ptr[1]; - if (next >= 0xDC00 && next <= 0xDFFF) - return 0x10000 + ((u - 0xD800) << 10) + (next - 0xDC00); - } - return u; -} - - -size_t uv_utf16_length_as_wtf8(const uint16_t* w_source_ptr, - ssize_t w_source_len) { - size_t target_len; - int32_t code_point; - - target_len = 0; - while (w_source_len) { - code_point = uv__get_surrogate_value(w_source_ptr, w_source_len); - /* Can be invalid UTF-8 but must be valid WTF-8. */ - assert(code_point >= 0); - if (w_source_len < 0 && code_point == 0) - break; - if (code_point < 0x80) - target_len += 1; - else if (code_point < 0x800) - target_len += 2; - else if (code_point < 0x10000) - target_len += 3; - else { - target_len += 4; - w_source_ptr++; - if (w_source_len > 0) - w_source_len--; - } - w_source_ptr++; - if (w_source_len > 0) - w_source_len--; - } - - return target_len; -} - - -int uv_utf16_to_wtf8(const uint16_t* w_source_ptr, - ssize_t w_source_len, - char** target_ptr, - size_t* target_len_ptr) { - size_t target_len; - char* target; - char* target_end; - int32_t code_point; - - /* If *target_ptr is provided, then *target_len_ptr must be its length - * (excluding space for NUL), otherwise we will compute the target_len_ptr - * length and may return a new allocation in *target_ptr if target_ptr is - * provided. */ - if (target_ptr == NULL || *target_ptr == NULL) { - target_len = uv_utf16_length_as_wtf8(w_source_ptr, w_source_len); - if (target_len_ptr != NULL) - *target_len_ptr = target_len; - } else { - target_len = *target_len_ptr; - } - - if (target_ptr == NULL) - return 0; - - if (*target_ptr == NULL) { - target = uv__malloc(target_len + 1); - if (target == NULL) { - return UV_ENOMEM; - } - *target_ptr = target; - } else { - target = *target_ptr; - } - - target_end = target + target_len; - - while (target != target_end && w_source_len) { - code_point = uv__get_surrogate_value(w_source_ptr, w_source_len); - /* Can be invalid UTF-8 but must be valid WTF-8. */ - assert(code_point >= 0); - if (w_source_len < 0 && code_point == 0) { - w_source_len = 0; - break; - } - if (code_point < 0x80) { - *target++ = code_point; - } else if (code_point < 0x800) { - *target++ = 0xC0 | (code_point >> 6); - if (target == target_end) - break; - *target++ = 0x80 | (code_point & 0x3F); - } else if (code_point < 0x10000) { - *target++ = 0xE0 | (code_point >> 12); - if (target == target_end) - break; - *target++ = 0x80 | ((code_point >> 6) & 0x3F); - if (target == target_end) - break; - *target++ = 0x80 | (code_point & 0x3F); - } else { - *target++ = 0xF0 | (code_point >> 18); - if (target == target_end) - break; - *target++ = 0x80 | ((code_point >> 12) & 0x3F); - if (target == target_end) - break; - *target++ = 0x80 | ((code_point >> 6) & 0x3F); - if (target == target_end) - break; - *target++ = 0x80 | (code_point & 0x3F); - /* uv__get_surrogate_value consumed 2 input characters */ - w_source_ptr++; - if (w_source_len > 0) - w_source_len--; - } - target_len = target - *target_ptr; - w_source_ptr++; - if (w_source_len > 0) - w_source_len--; - } - - if (target != target_end && target_len_ptr != NULL) - /* Did not fill all of the provided buffer, so update the target_len_ptr - * output with the space used. */ - *target_len_ptr = target - *target_ptr; - - /* Check if input fit into target exactly. */ - if (w_source_len < 0 && target == target_end && w_source_ptr[0] == 0) - w_source_len = 0; - - *target++ = '\0'; - - /* Characters remained after filling the buffer, compute the remaining length now. */ - if (w_source_len) { - if (target_len_ptr != NULL) - *target_len_ptr = target_len + uv_utf16_length_as_wtf8(w_source_ptr, w_source_len); - return UV_ENOBUFS; - } - - return 0; -} diff --git a/src/idna.h b/src/idna.h index ea6b4df..8e0c592 100644 --- a/src/idna.h +++ b/src/idna.h @@ -1,4 +1,4 @@ -/* Copyright libuv contributors. All rights reserved. +/* Copyright (c) 2011, 2018 Ben Noordhuis * * Permission to use, copy, modify, and/or distribute this software for any * purpose with or without fee is hereby granted, provided that the above @@ -26,6 +26,6 @@ unsigned uv__utf8_decode1(const char** p, const char* pe); * is the number of bytes written to |d|, including the trailing nul byte. * A return value < 0 is a libuv error code. |s| and |d| can not overlap. */ -ssize_t uv__idna_toascii(const char* s, const char* se, char* d, char* de); +long uv__idna_toascii(const char* s, const char* se, char* d, char* de); #endif /* UV_SRC_IDNA_H_ */ diff --git a/src/inet.c b/src/inet.c index cd77496..ddabf22 100644 --- a/src/inet.c +++ b/src/inet.c @@ -17,7 +17,12 @@ #include #include -#include + +#if defined(_MSC_VER) && _MSC_VER < 1600 +# include "uv/stdint-msvc2008.h" +#else +# include +#endif #include "uv.h" #include "uv-common.h" @@ -130,7 +135,7 @@ static int inet_ntop6(const unsigned char *src, char *dst, size_t size) { tp += strlen(tp); break; } - tp += snprintf(tp, sizeof tmp - (tp - tmp), "%x", words[i]); + tp += sprintf(tp, "%x", words[i]); } /* Was it a trailing run of 0x00's? */ if (best.base != -1 && (best.base + best.len) == ARRAY_SIZE(words)) diff --git a/src/queue.h b/src/queue.h index ec7f797..11033cd 100644 --- a/src/queue.h +++ b/src/queue.h @@ -18,86 +18,108 @@ #include -#define uv__queue_data(pointer, type, field) \ - ((type*) ((char*) (pointer) - offsetof(type, field))) - -#define uv__queue_foreach(q, h) \ - for ((q) = (h)->next; (q) != (h); (q) = (q)->next) - -static inline void uv__queue_init(struct uv__queue* q) { - q->next = q; - q->prev = q; -} - -static inline int uv__queue_empty(const struct uv__queue* q) { - return q == q->next || q != q->next->prev; -} - -static inline struct uv__queue* uv__queue_head(const struct uv__queue* q) { - return q->next; -} - -static inline struct uv__queue* uv__queue_next(const struct uv__queue* q) { - return q->next; -} - -static inline void uv__queue_add(struct uv__queue* h, struct uv__queue* n) { - h->prev->next = n->next; - n->next->prev = h->prev; - h->prev = n->prev; - h->prev->next = h; -} - -static inline void uv__queue_split(struct uv__queue* h, - struct uv__queue* q, - struct uv__queue* n) { - n->prev = h->prev; - n->prev->next = n; - n->next = q; - h->prev = q->prev; - h->prev->next = h; - q->prev = n; -} - -static inline void uv__queue_move(struct uv__queue* h, struct uv__queue* n) { - if (uv__queue_empty(h)) - uv__queue_init(n); - else - uv__queue_split(h, h->next, n); -} - -static inline void uv__queue_insert_head(struct uv__queue* h, - struct uv__queue* q) { - q->next = h->next; - q->prev = h; - q->next->prev = q; - h->next = q; -} - -static inline void uv__queue_insert_tail(struct uv__queue* h, - struct uv__queue* q) { - q->next = h; - q->prev = h->prev; - q->prev->next = q; - h->prev = q; -} - -static inline void uv__queue_remove(struct uv__queue* q) { - q->prev->next = q->next; - q->next->prev = q->prev; -} +typedef void *QUEUE[2]; + +/* Private macros. */ +#define QUEUE_NEXT(q) (*(QUEUE **) &((*(q))[0])) +#define QUEUE_PREV(q) (*(QUEUE **) &((*(q))[1])) +#define QUEUE_PREV_NEXT(q) (QUEUE_NEXT(QUEUE_PREV(q))) +#define QUEUE_NEXT_PREV(q) (QUEUE_PREV(QUEUE_NEXT(q))) + +/* Public macros. */ +#define QUEUE_DATA(ptr, type, field) \ + ((type *) ((char *) (ptr) - offsetof(type, field))) + +/* Important note: mutating the list while QUEUE_FOREACH is + * iterating over its elements results in undefined behavior. + */ +#define QUEUE_FOREACH(q, h) \ + for ((q) = QUEUE_NEXT(h); (q) != (h); (q) = QUEUE_NEXT(q)) + +#define QUEUE_EMPTY(q) \ + ((const QUEUE *) (q) == (const QUEUE *) QUEUE_NEXT(q) || \ + (const QUEUE *) (q) != (const QUEUE *) QUEUE_PREV(QUEUE_NEXT(q))) +/* treat broken queue as empty */ + +#define QUEUE_HEAD(q) \ + (QUEUE_NEXT(q)) + +#define QUEUE_INIT(q) \ + do { \ + QUEUE_NEXT(q) = (q); \ + QUEUE_PREV(q) = (q); \ + } \ + while (0) + +#define QUEUE_ADD(h, n) \ + do { \ + QUEUE_PREV_NEXT(h) = QUEUE_NEXT(n); \ + QUEUE_NEXT_PREV(n) = QUEUE_PREV(h); \ + QUEUE_PREV(h) = QUEUE_PREV(n); \ + QUEUE_PREV_NEXT(h) = (h); \ + } \ + while (0) + +#define QUEUE_SPLIT(h, q, n) \ + do { \ + QUEUE_PREV(n) = QUEUE_PREV(h); \ + QUEUE_PREV_NEXT(n) = (n); \ + QUEUE_NEXT(n) = (q); \ + QUEUE_PREV(h) = QUEUE_PREV(q); \ + QUEUE_PREV_NEXT(h) = (h); \ + QUEUE_PREV(q) = (n); \ + } \ + while (0) + +#define QUEUE_MOVE(h, n) \ + do { \ + if (QUEUE_EMPTY(h)) \ + QUEUE_INIT(n); \ + else { \ + QUEUE* q = QUEUE_HEAD(h); \ + QUEUE_SPLIT(h, q, n); \ + } \ + } \ + while (0) + +#define QUEUE_INSERT_HEAD(h, q) \ + do { \ + QUEUE_NEXT(q) = QUEUE_NEXT(h); \ + QUEUE_PREV(q) = (h); \ + QUEUE_NEXT_PREV(q) = (q); \ + QUEUE_NEXT(h) = (q); \ + } \ + while (0) + +#define QUEUE_INSERT_TAIL(h, q) \ + do { \ + QUEUE_NEXT(q) = (h); \ + QUEUE_PREV(q) = QUEUE_PREV(h); \ + QUEUE_PREV_NEXT(q) = (q); \ + QUEUE_PREV(h) = (q); \ + } \ + while (0) + +#define QUEUE_REMOVE(q) \ + do { \ + QUEUE_PREV_NEXT(q) = QUEUE_NEXT(q); \ + QUEUE_NEXT_PREV(q) = QUEUE_PREV(q); \ + } \ + while (0) #ifdef USE_FFRT -static inline void uv__queue_append(struct uv__queue* h, struct uv__queue* n) { - struct uv__queue* q = h->next; - struct uv__queue* p = n->prev; - n->prev = h->prev; - n->prev->next = n; - p->next = q; - h->prev = q->prev; - h->prev->next = h; - q->prev = p; -} +#define QUEUE_APPEND(h, n) \ + do { \ + QUEUE* q = QUEUE_HEAD(h); \ + QUEUE* p = QUEUE_PREV(n); \ + QUEUE_PREV(n) = QUEUE_PREV(h); \ + QUEUE_PREV_NEXT(n) = (n); \ + QUEUE_NEXT(p) = (q); \ + QUEUE_PREV(h) = QUEUE_PREV(q); \ + QUEUE_PREV_NEXT(h) = (h); \ + QUEUE_PREV(q) = (p); \ + } \ + while (0) #endif #endif /* QUEUE_H_ */ diff --git a/src/random.c b/src/random.c index a6917ca..6fd810d 100644 --- a/src/random.c +++ b/src/random.c @@ -114,9 +114,9 @@ int uv_random(uv_loop_t* loop, req->buflen = buflen; uv__work_submit(loop, -#ifdef USE_FFRT + #ifdef USE_FFRT (uv_req_t*)req, -#endif + #endif &req->work_req, UV__WORK_CPU, uv__random_work, diff --git a/src/thread-common.c b/src/thread-common.c deleted file mode 100644 index c67c0a7..0000000 --- a/src/thread-common.c +++ /dev/null @@ -1,175 +0,0 @@ -/* Copyright libuv project contributors. All rights reserved. - * - * Permission is hereby granted, free of charge, to any person obtaining a copy - * of this software and associated documentation files (the "Software"), to - * deal in the Software without restriction, including without limitation the - * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or - * sell copies of the Software, and to permit persons to whom the Software is - * furnished to do so, subject to the following conditions: - * - * The above copyright notice and this permission notice shall be included in - * all copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING - * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS - * IN THE SOFTWARE. - */ - -#include "uv.h" -#include "uv-common.h" - -#include -#ifndef _WIN32 -#include -#endif - -#if defined(PTHREAD_BARRIER_SERIAL_THREAD) -STATIC_ASSERT(sizeof(uv_barrier_t) == sizeof(pthread_barrier_t)); -#endif - -/* Note: guard clauses should match uv_barrier_t's in include/uv/unix.h. */ -#if defined(_AIX) || \ - defined(__OpenBSD__) || \ - !defined(PTHREAD_BARRIER_SERIAL_THREAD) -int uv_barrier_init(uv_barrier_t* barrier, unsigned int count) { - int rc; -#ifdef _WIN32 - uv_barrier_t* b; - b = barrier; - - if (barrier == NULL || count == 0) - return UV_EINVAL; -#else - struct _uv_barrier* b; - - if (barrier == NULL || count == 0) - return UV_EINVAL; - - b = uv__malloc(sizeof(*b)); - if (b == NULL) - return UV_ENOMEM; -#endif - - b->in = 0; - b->out = 0; - b->threshold = count; - - rc = uv_mutex_init(&b->mutex); - if (rc != 0) - goto error2; - - /* TODO(vjnash): remove these uv_cond_t casts in v2. */ - rc = uv_cond_init((uv_cond_t*) &b->cond); - if (rc != 0) - goto error; - -#ifndef _WIN32 - barrier->b = b; -#endif - return 0; - -error: - uv_mutex_destroy(&b->mutex); -error2: -#ifndef _WIN32 - uv__free(b); -#endif - return rc; -} - - -int uv_barrier_wait(uv_barrier_t* barrier) { - int last; -#ifdef _WIN32 - uv_barrier_t* b; - b = barrier; -#else - struct _uv_barrier* b; - - if (barrier == NULL || barrier->b == NULL) - return UV_EINVAL; - - b = barrier->b; -#endif - - uv_mutex_lock(&b->mutex); - - while (b->out != 0) - uv_cond_wait((uv_cond_t*) &b->cond, &b->mutex); - - if (++b->in == b->threshold) { - b->in = 0; - b->out = b->threshold; - uv_cond_broadcast((uv_cond_t*) &b->cond); - } else { - do - uv_cond_wait((uv_cond_t*) &b->cond, &b->mutex); - while (b->in != 0); - } - - last = (--b->out == 0); - if (last) - uv_cond_broadcast((uv_cond_t*) &b->cond); - - uv_mutex_unlock(&b->mutex); - return last; -} - - -void uv_barrier_destroy(uv_barrier_t* barrier) { -#ifdef _WIN32 - uv_barrier_t* b; - b = barrier; -#else - struct _uv_barrier* b; - b = barrier->b; -#endif - - uv_mutex_lock(&b->mutex); - - assert(b->in == 0); - while (b->out != 0) - uv_cond_wait((uv_cond_t*) &b->cond, &b->mutex); - - if (b->in != 0) - abort(); - - uv_mutex_unlock(&b->mutex); - uv_mutex_destroy(&b->mutex); - uv_cond_destroy((uv_cond_t*) &b->cond); - -#ifndef _WIN32 - uv__free(barrier->b); - barrier->b = NULL; -#endif -} - -#else - -int uv_barrier_init(uv_barrier_t* barrier, unsigned int count) { - return UV__ERR(pthread_barrier_init(barrier, NULL, count)); -} - - -int uv_barrier_wait(uv_barrier_t* barrier) { - int rc; - - rc = pthread_barrier_wait(barrier); - if (rc != 0) - if (rc != PTHREAD_BARRIER_SERIAL_THREAD) - abort(); - - return rc == PTHREAD_BARRIER_SERIAL_THREAD; -} - - -void uv_barrier_destroy(uv_barrier_t* barrier) { - if (pthread_barrier_destroy(barrier)) - abort(); -} - -#endif diff --git a/src/threadpool.c b/src/threadpool.c index 4a1ac04..098e7ad 100644 --- a/src/threadpool.c +++ b/src/threadpool.c @@ -40,19 +40,17 @@ #define UV_TRACE_NAME "UV_TRACE" static uv_rwlock_t g_closed_uv_loop_rwlock; -static uv_once_t once = UV_ONCE_INIT; + static uv_cond_t cond; static uv_mutex_t mutex; static unsigned int idle_threads; -static unsigned int slow_io_work_running; static unsigned int nthreads; static uv_thread_t* threads; static uv_thread_t default_threads[4]; -static struct uv__queue exit_message; -static struct uv__queue wq; -static struct uv__queue run_slow_work_message; -static struct uv__queue slow_io_pending_wq; - +static QUEUE exit_message; +static QUEUE wq; +static QUEUE run_slow_work_message; +static QUEUE slow_io_pending_wq; #ifdef ASYNC_STACKTRACE #include "dfx/async_stack/libuv_async_stack.h" @@ -72,35 +70,35 @@ static uv_thread_t dump_thread; static void uv_dump_worker(void* arg) { struct uv__statistic_work* w; - struct uv__queue* q; + QUEUE* q; uv_sem_post((uv_sem_t*) arg); arg = NULL; uv_mutex_lock(&statistic_mutex); for (;;) { - while (uv__queue_empty(&statistic_works)) { + while (QUEUE_EMPTY(&statistic_works)) { statistic_idle = 1; uv_cond_wait(&dump_cond, &statistic_mutex); statistic_idle = 0; } - q = uv__queue_head(&statistic_works); + q = QUEUE_HEAD(&statistic_works); if (q == &exit_message) { uv_cond_signal(&dump_cond); uv_mutex_unlock(&statistic_mutex); break; } - uv__queue_remove(q); - uv__queue_init(q); + QUEUE_REMOVE(q); + QUEUE_INIT(q); uv_mutex_unlock(&statistic_mutex); - w = uv__queue_data(q, struct uv__statistic_work, wq); + w = QUEUE_DATA(q, struct uv__statistic_work, wq); w->work(w); free(w); uv_mutex_lock(&statistic_mutex); } } -static void post_statistic_work(struct uv__queue* q) { +static void post_statistic_work(QUEUE* q) { uv_mutex_lock(&statistic_mutex); - uv__queue_insert_tail(&statistic_works, q); + QUEUE_INSERT_TAIL(&statistic_works, q); if (statistic_idle) uv_cond_signal(&dump_cond); uv_mutex_unlock(&statistic_mutex); @@ -109,11 +107,11 @@ static void post_statistic_work(struct uv__queue* q) { static void uv__queue_work_info(struct uv__statistic_work *work) { uv_mutex_lock(&dump_queue_mutex); if (dump_queue_size + 1 > MAX_DUMP_QUEUE_SIZE) { /* release works already done */ - struct uv__queue* q; - uv__queue_foreach(q, &dump_queue) { - struct uv_work_dump_info* info = uv__queue_data(q, struct uv_work_dump_info, wq); + QUEUE* q; + QUEUE_FOREACH(q, &dump_queue) { + struct uv_work_dump_info* info = QUEUE_DATA(q, struct uv_work_dump_info, wq); if (info->state == DONE_END) { - uv__queue_remove(q); + QUEUE_REMOVE(q); free(info); dump_queue_size--; } @@ -123,7 +121,7 @@ static void uv__queue_work_info(struct uv__statistic_work *work) { } } - uv__queue_insert_head(&dump_queue, &work->info->wq); + QUEUE_INSERT_HEAD(&dump_queue, &work->info->wq); dump_queue_size++; uv_mutex_unlock(&dump_queue_mutex); } @@ -176,7 +174,7 @@ static void uv__post_statistic_work(struct uv__work *w, enum uv_work_state state dump_work->work = uv__update_work_info; dump_work->time = uv__now_timestamp(); dump_work->state = state; - uv__queue_init(&dump_work->wq); + QUEUE_INIT(&dump_work->wq); post_statistic_work(&dump_work->wq); } @@ -186,7 +184,7 @@ static void init_work_dump_queue() if (uv_mutex_init(&dump_queue_mutex)) abort(); uv_mutex_lock(&dump_queue_mutex); - uv__queue_init(&dump_queue); + QUEUE_INIT(&dump_queue); dump_queue_size = 0; uv_mutex_unlock(&dump_queue_mutex); @@ -194,7 +192,7 @@ static void init_work_dump_queue() statistic_idle = 1; if (uv_mutex_init(&statistic_mutex)) abort(); - uv__queue_init(&statistic_works); + QUEUE_INIT(&statistic_works); uv_sem_t sem; if (uv_cond_init(&dump_cond)) abort(); @@ -217,7 +215,7 @@ void uv_init_dump_info(struct uv_work_dump_info* info, struct uv__work* w) { info->done_start_time = 0; info->done_end_time = 0; info->work = w; - uv__queue_init(&info->wq); + QUEUE_INIT(&info->wq); } @@ -230,7 +228,7 @@ void uv_queue_statics(struct uv_work_dump_info* info) { dump_work->work = uv__queue_work_info; info->queue_time = uv__now_timestamp(); dump_work->state = WAITING; - uv__queue_init(&dump_work->wq); + QUEUE_INIT(&dump_work->wq); post_statistic_work(&dump_work->wq); } @@ -238,15 +236,15 @@ void uv_queue_statics(struct uv_work_dump_info* info) { uv_worker_info_t* uv_dump_work_queue(int* size) { #ifdef UV_STATISTIC uv_mutex_lock(&dump_queue_mutex); - if (uv__queue_empty(&dump_queue)) { + if (QUEUE_EMPTY(&dump_queue)) { return NULL; } *size = dump_queue_size; uv_worker_info_t* dump_info = (uv_worker_info_t*) malloc(sizeof(uv_worker_info_t) * dump_queue_size); - struct uv__queue* q; + QUEUE* q; int i = 0; - uv__queue_foreach(q, &dump_queue) { - struct uv_work_dump_info* info = uv__queue_data(q, struct uv_work_dump_info, wq); + QUEUE_FOREACH(q, &dump_queue) { + struct uv_work_dump_info* info = QUEUE_DATA(q, struct uv_work_dump_info, wq); dump_info[i].queue_time = info->queue_time; dump_info[i].builtin_return_address[0] = info->builtin_return_address[0]; dump_info[i].builtin_return_address[1] = info->builtin_return_address[1]; @@ -325,7 +323,7 @@ static void uv__cancelled(struct uv__work* w) { abort(); } - +static uv_once_t once = UV_ONCE_INIT; #ifndef USE_FFRT static unsigned int slow_io_work_running; @@ -339,7 +337,7 @@ static unsigned int slow_work_thread_threshold(void) { */ static void worker(void* arg) { struct uv__work* w; - struct uv__queue* q; + QUEUE* q; int is_slow_work; uv_sem_post((uv_sem_t*) arg); @@ -351,49 +349,49 @@ static void worker(void* arg) { /* Keep waiting while either no work is present or only slow I/O and we're at the threshold for that. */ - while (uv__queue_empty(&wq) || - (uv__queue_head(&wq) == &run_slow_work_message && - uv__queue_next(&run_slow_work_message) == &wq && + while (QUEUE_EMPTY(&wq) || + (QUEUE_HEAD(&wq) == &run_slow_work_message && + QUEUE_NEXT(&run_slow_work_message) == &wq && slow_io_work_running >= slow_work_thread_threshold())) { idle_threads += 1; uv_cond_wait(&cond, &mutex); idle_threads -= 1; } - q = uv__queue_head(&wq); + q = QUEUE_HEAD(&wq); if (q == &exit_message) { uv_cond_signal(&cond); uv_mutex_unlock(&mutex); break; } - uv__queue_remove(q); - uv__queue_init(q); /* Signal uv_cancel() that the work req is executing. */ + QUEUE_REMOVE(q); + QUEUE_INIT(q); /* Signal uv_cancel() that the work req is executing. */ is_slow_work = 0; if (q == &run_slow_work_message) { /* If we're at the slow I/O threshold, re-schedule until after all other work in the queue is done. */ if (slow_io_work_running >= slow_work_thread_threshold()) { - uv__queue_insert_tail(&wq, q); + QUEUE_INSERT_TAIL(&wq, q); continue; } /* If we encountered a request to run slow I/O work but there is none to run, that means it's cancelled => Start over. */ - if (uv__queue_empty(&slow_io_pending_wq)) + if (QUEUE_EMPTY(&slow_io_pending_wq)) continue; is_slow_work = 1; slow_io_work_running++; - q = uv__queue_head(&slow_io_pending_wq); - uv__queue_remove(q); - uv__queue_init(q); + q = QUEUE_HEAD(&slow_io_pending_wq); + QUEUE_REMOVE(q); + QUEUE_INIT(q); /* If there is more slow I/O work, schedule it to be run as well. */ - if (!uv__queue_empty(&slow_io_pending_wq)) { - uv__queue_insert_tail(&wq, &run_slow_work_message); + if (!QUEUE_EMPTY(&slow_io_pending_wq)) { + QUEUE_INSERT_TAIL(&wq, &run_slow_work_message); if (idle_threads > 0) uv_cond_signal(&cond); } @@ -401,7 +399,7 @@ static void worker(void* arg) { uv_mutex_unlock(&mutex); - w = uv__queue_data(q, struct uv__work, wq); + w = QUEUE_DATA(q, struct uv__work, wq); #ifdef UV_STATISTIC uv__post_statistic_work(w, WORK_EXECUTING); #endif @@ -416,7 +414,7 @@ static void worker(void* arg) { uv_mutex_lock(&w->loop->wq_mutex); w->work = NULL; /* Signal uv_cancel() that the work req is done executing. */ - uv__queue_insert_tail(&w->loop->wq, &w->wq); + QUEUE_INSERT_TAIL(&w->loop->wq, &w->wq); uv_async_send(&w->loop->wq_async); uv_mutex_unlock(&w->loop->wq_mutex); @@ -432,12 +430,12 @@ static void worker(void* arg) { #endif -static void post(struct uv__queue* q, enum uv__work_kind kind) { +static void post(QUEUE* q, enum uv__work_kind kind) { uv_mutex_lock(&mutex); if (kind == UV__WORK_SLOW_IO) { /* Insert into a separate queue. */ - uv__queue_insert_tail(&slow_io_pending_wq, q); - if (!uv__queue_empty(&run_slow_work_message)) { + QUEUE_INSERT_TAIL(&slow_io_pending_wq, q); + if (!QUEUE_EMPTY(&run_slow_work_message)) { /* Running slow I/O tasks is already scheduled => Nothing to do here. The worker that runs said other task will schedule this one as well. */ uv_mutex_unlock(&mutex); @@ -446,7 +444,7 @@ static void post(struct uv__queue* q, enum uv__work_kind kind) { q = &run_slow_work_message; } - uv__queue_insert_tail(&wq, q); + QUEUE_INSERT_TAIL(&wq, q); if (idle_threads > 0) uv_cond_signal(&cond); uv_mutex_unlock(&mutex); @@ -491,7 +489,6 @@ void uv__threadpool_cleanup(void) { #ifndef USE_FFRT static void init_threads(void) { - uv_thread_options_t config; unsigned int i; const char* val; uv_sem_t sem; @@ -520,18 +517,15 @@ static void init_threads(void) { if (uv_mutex_init(&mutex)) abort(); - uv__queue_init(&wq); - uv__queue_init(&slow_io_pending_wq); - uv__queue_init(&run_slow_work_message); + QUEUE_INIT(&wq); + QUEUE_INIT(&slow_io_pending_wq); + QUEUE_INIT(&run_slow_work_message); if (uv_sem_init(&sem, 0)) abort(); - config.flags = UV_THREAD_HAS_STACK_SIZE; - config.stack_size = 8u << 20; /* 8 MB */ - for (i = 0; i < nthreads; i++) - if (uv_thread_create_ex(threads + i, &config, worker, &sem)) + if (uv_thread_create(threads + i, worker, &sem)) abort(); for (i = 0; i < nthreads; i++) @@ -588,9 +582,6 @@ static void uv__task_done_wrapper(void* work, int status) { #endif -/* TODO(bnoordhuis) teach libuv how to cancel file operations - * that go through io_uring instead of the thread pool. - */ static int uv__work_cancel(uv_loop_t* loop, uv_req_t* req, struct uv__work* w) { int cancelled; @@ -604,15 +595,15 @@ static int uv__work_cancel(uv_loop_t* loop, uv_req_t* req, struct uv__work* w) { uv_mutex_lock(&mutex); uv_mutex_lock(&w->loop->wq_mutex); - cancelled = !uv__queue_empty(&w->wq) && w->work != NULL; + cancelled = !QUEUE_EMPTY(&w->wq) && w->work != NULL; if (cancelled) - uv__queue_remove(&w->wq); + QUEUE_REMOVE(&w->wq); uv_mutex_unlock(&w->loop->wq_mutex); uv_mutex_unlock(&mutex); #else uv_mutex_lock(&w->loop->wq_mutex); - cancelled = !uv__queue_empty(&w->wq) && w->work != NULL + cancelled = !QUEUE_EMPTY(&w->wq) && w->work != NULL && ffrt_executor_task_cancel(w, (ffrt_qos_t)(intptr_t)req->reserved[0]); uv_mutex_unlock(&w->loop->wq_mutex); #endif @@ -625,7 +616,7 @@ static int uv__work_cancel(uv_loop_t* loop, uv_req_t* req, struct uv__work* w) { w->work = uv__cancelled; uv_mutex_lock(&loop->wq_mutex); #ifndef USE_FFRT - uv__queue_insert_tail(&loop->wq, &w->wq); + QUEUE_INSERT_TAIL(&loop->wq, &w->wq); uv_async_send(&loop->wq_async); #else uv__loop_internal_fields_t* lfields = uv__get_internal_fields(w->loop); @@ -637,7 +628,7 @@ static int uv__work_cancel(uv_loop_t* loop, uv_req_t* req, struct uv__work* w) { (UV_EVENT_MAGIC_OFFSET << UV_EVENT_MAGIC_OFFSETBITS)); addr->post_task_func(addr->event_handler, uv__task_done_wrapper, (void*)w, status, qos); } else { - uv__queue_insert_tail(&(lfields->wq_sub[qos]), &w->wq); + QUEUE_INSERT_TAIL(&(lfields->wq_sub[qos]), &w->wq); uv_async_send(&loop->wq_async); } #endif @@ -651,10 +642,9 @@ static int uv__work_cancel(uv_loop_t* loop, uv_req_t* req, struct uv__work* w) { void uv__work_done(uv_async_t* handle) { struct uv__work* w; uv_loop_t* loop; - struct uv__queue* q; - struct uv__queue wq; + QUEUE* q; + QUEUE wq; int err; - int nevents; loop = container_of(handle, uv_loop_t, wq_async); rdlock_closed_uv_loop_rwlock(); @@ -664,24 +654,23 @@ void uv__work_done(uv_async_t* handle) { } uv_mutex_lock(&loop->wq_mutex); #ifndef USE_FFRT - uv__queue_move(&loop->wq, &wq); + QUEUE_MOVE(&loop->wq, &wq); #else uv__loop_internal_fields_t* lfields = uv__get_internal_fields(loop); int i; - uv__queue_init(&wq); + QUEUE_INIT(&wq); for (i = 3; i >= 0; i--) { - if (!uv__queue_empty(&lfields->wq_sub[i])) { - uv__queue_append(&lfields->wq_sub[i], &wq); + if (!QUEUE_EMPTY(&lfields->wq_sub[i])) { + QUEUE_APPEND(&lfields->wq_sub[i], &wq); } } #endif uv_mutex_unlock(&loop->wq_mutex); - nevents = 0; uv_start_trace(UV_TRACE_TAG, UV_TRACE_NAME); - while (!uv__queue_empty(&wq)) { - q = uv__queue_head(&wq); - uv__queue_remove(q); + while (!QUEUE_EMPTY(&wq)) { + q = QUEUE_HEAD(&wq); + QUEUE_REMOVE(q); w = container_of(q, struct uv__work, wq); err = (w->work == uv__cancelled) ? UV_ECANCELED : 0; @@ -700,7 +689,6 @@ void uv__work_done(uv_async_t* handle) { LibuvSetStackId((uint64_t)req->reserved[3]); #endif w->done(w, err); - nevents++; #ifdef UV_STATISTIC dump_work->time = uv__now_timestamp(); dump_work->state = DONE_END; @@ -710,19 +698,6 @@ void uv__work_done(uv_async_t* handle) { } uv_end_trace(UV_TRACE_TAG); rdunlock_closed_uv_loop_rwlock(); - - /* This check accomplishes 2 things: - * 1. Even if the queue was empty, the call to uv__work_done() should count - * as an event. Which will have been added by the event loop when - * calling this callback. - * 2. Prevents accidental wrap around in case nevents == 0 events == 0. - */ - if (nevents > 1) { - /* Subtract 1 to counter the call to uv__work_done(). */ - uv__metrics_inc_events(loop, nevents - 1); - if (uv__get_internal_fields(loop)->current_timeout == 0) - uv__metrics_inc_events_waiting(loop, nevents - 1); - } } @@ -772,8 +747,8 @@ void uv__ffrt_work(ffrt_executor_task_t* data, ffrt_qos_t qos) if (loop->magic != UV_LOOP_MAGIC || !lfields || qos >= ARRAY_SIZE(lfields->wq_sub) - || !lfields->wq_sub[qos].next - || !lfields->wq_sub[qos].prev) { + || !lfields->wq_sub[qos][0] + || !lfields->wq_sub[qos][1]) { rdunlock_closed_uv_loop_rwlock(); UV_LOGE("uv_loop(%{public}zu:%{public}#x) in task(%p:%p) is invalid", (size_t)loop, loop->magic, req->work_cb, req->after_work_cb); @@ -789,7 +764,7 @@ void uv__ffrt_work(ffrt_executor_task_t* data, ffrt_qos_t qos) (UV_EVENT_MAGIC_OFFSET << UV_EVENT_MAGIC_OFFSETBITS)); addr->post_task_func(addr->event_handler, uv__task_done_wrapper, (void*)w, status, qos); } else { - uv__queue_insert_tail(&(lfields->wq_sub[qos]), &w->wq); + QUEUE_INSERT_TAIL(&(lfields->wq_sub[qos]), &w->wq); uv_async_send(&loop->wq_async); } uv_mutex_unlock(&loop->wq_mutex); diff --git a/src/timer.c b/src/timer.c index 5bfb05f..0734f43 100644 --- a/src/timer.c +++ b/src/timer.c @@ -43,8 +43,8 @@ static int timer_less_than(const struct heap_node* ha, const uv_timer_t* a; const uv_timer_t* b; - a = container_of(ha, uv_timer_t, node.heap); - b = container_of(hb, uv_timer_t, node.heap); + a = container_of(ha, uv_timer_t, heap_node); + b = container_of(hb, uv_timer_t, heap_node); if (a->timeout < b->timeout) return 1; @@ -63,7 +63,6 @@ int uv_timer_init(uv_loop_t* loop, uv_timer_t* handle) { handle->timer_cb = NULL; handle->timeout = 0; handle->repeat = 0; - uv__queue_init(&handle->node.queue); return 0; } @@ -77,7 +76,8 @@ int uv_timer_start(uv_timer_t* handle, if (uv__is_closing(handle) || cb == NULL) return UV_EINVAL; - uv_timer_stop(handle); + if (uv__is_active(handle)) + uv_timer_stop(handle); clamped_timeout = handle->loop->time + timeout; if (clamped_timeout < timeout) @@ -94,7 +94,7 @@ int uv_timer_start(uv_timer_t* handle, #endif heap_insert(timer_heap(handle->loop), - (struct heap_node*) &handle->node.heap, + (struct heap_node*) &handle->heap_node, timer_less_than); uv__handle_start(handle); @@ -108,19 +108,14 @@ int uv_timer_start(uv_timer_t* handle, int uv_timer_stop(uv_timer_t* handle) { - if (uv__is_active(handle)) { - heap_remove(timer_heap(handle->loop), - (struct heap_node*) &handle->node.heap, - timer_less_than); - uv__handle_stop(handle); - } else { - if (handle->node.queue.next == NULL || handle->node.queue.prev) { - return 0; - } - uv__queue_remove(&handle->node.queue); - } + if (!uv__is_active(handle)) + return 0; + + heap_remove(timer_heap(handle->loop), + (struct heap_node*) &handle->heap_node, + timer_less_than); + uv__handle_stop(handle); - uv__queue_init(&handle->node.queue); return 0; } @@ -165,7 +160,7 @@ int uv__next_timeout(const uv_loop_t* loop) { if (heap_node == NULL) return -1; /* block indefinitely */ - handle = container_of(heap_node, uv_timer_t, node.heap); + handle = container_of(heap_node, uv_timer_t, heap_node); if (handle->timeout <= loop->time) return 0; @@ -180,30 +175,17 @@ int uv__next_timeout(const uv_loop_t* loop) { void uv__run_timers(uv_loop_t* loop) { struct heap_node* heap_node; uv_timer_t* handle; - struct uv__queue* queue_node; - struct uv__queue ready_queue; - - uv__queue_init(&ready_queue); for (;;) { heap_node = heap_min(timer_heap(loop)); if (heap_node == NULL) break; - handle = container_of(heap_node, uv_timer_t, node.heap); + handle = container_of(heap_node, uv_timer_t, heap_node); if (handle->timeout > loop->time) break; uv_timer_stop(handle); - uv__queue_insert_tail(&ready_queue, &handle->node.queue); - } - - while (!uv__queue_empty(&ready_queue)) { - queue_node = uv__queue_head(&ready_queue); - uv__queue_remove(queue_node); - uv__queue_init(queue_node); - handle = container_of(queue_node, uv_timer_t, node.queue); - uv_timer_again(handle); #ifdef ASYNC_STACKTRACE LibuvSetStackId((uint64_t)handle->u.reserved[3]); diff --git a/src/unix/aix.c b/src/unix/aix.c index 3af3009..6a013d4 100644 --- a/src/unix/aix.c +++ b/src/unix/aix.c @@ -131,12 +131,11 @@ int uv__io_check_fd(uv_loop_t* loop, int fd) { void uv__io_poll(uv_loop_t* loop, int timeout) { - uv__loop_internal_fields_t* lfields; struct pollfd events[1024]; struct pollfd pqry; struct pollfd* pe; struct poll_ctl pc; - struct uv__queue* q; + QUEUE* q; uv__io_t* w; uint64_t base; uint64_t diff; @@ -151,18 +150,16 @@ void uv__io_poll(uv_loop_t* loop, int timeout) { int reset_timeout; if (loop->nfds == 0) { - assert(uv__queue_empty(&loop->watcher_queue)); + assert(QUEUE_EMPTY(&loop->watcher_queue)); return; } - lfields = uv__get_internal_fields(loop); + while (!QUEUE_EMPTY(&loop->watcher_queue)) { + q = QUEUE_HEAD(&loop->watcher_queue); + QUEUE_REMOVE(q); + QUEUE_INIT(q); - while (!uv__queue_empty(&loop->watcher_queue)) { - q = uv__queue_head(&loop->watcher_queue); - uv__queue_remove(q); - uv__queue_init(q); - - w = uv__queue_data(q, uv__io_t, watcher_queue); + w = QUEUE_DATA(q, uv__io_t, watcher_queue); assert(w->pevents != 0); assert(w->fd >= 0); assert(w->fd < (int) loop->nwatchers); @@ -220,7 +217,7 @@ void uv__io_poll(uv_loop_t* loop, int timeout) { base = loop->time; count = 48; /* Benchmarks suggest this gives the best throughput. */ - if (lfields->flags & UV_METRICS_IDLE_TIME) { + if (uv__get_internal_fields(loop)->flags & UV_METRICS_IDLE_TIME) { reset_timeout = 1; user_timeout = timeout; timeout = 0; @@ -235,12 +232,6 @@ void uv__io_poll(uv_loop_t* loop, int timeout) { if (timeout != 0) uv__metrics_set_provider_entry_time(loop); - /* Store the current timeout in a location that's globally accessible so - * other locations like uv__work_done() can determine whether the queue - * of events in the callback were waiting when poll was called. - */ - lfields->current_timeout = timeout; - nfds = pollset_poll(loop->backend_fd, events, ARRAY_SIZE(events), @@ -330,11 +321,9 @@ void uv__io_poll(uv_loop_t* loop, int timeout) { nevents++; } - uv__metrics_inc_events(loop, nevents); if (reset_timeout != 0) { timeout = user_timeout; reset_timeout = 0; - uv__metrics_inc_events_waiting(loop, nevents); } if (have_signals != 0) { @@ -400,11 +389,6 @@ uint64_t uv_get_constrained_memory(void) { } -uint64_t uv_get_available_memory(void) { - return uv_get_free_memory(); -} - - void uv_loadavg(double avg[3]) { perfstat_cpu_total_t ps_total; int result = perfstat_cpu_total(NULL, &ps_total, sizeof(ps_total), 1); @@ -441,7 +425,7 @@ static char* uv__rawname(const char* cp, char (*dst)[FILENAME_MAX+1]) { static int uv__path_is_a_directory(char* filename) { struct stat statbuf; - if (uv__stat(filename, &statbuf) < 0) + if (stat(filename, &statbuf) < 0) return -1; /* failed: not a directory, assume it is a file */ if (statbuf.st_type == VDIR) diff --git a/src/unix/async.c b/src/unix/async.c index e0d9bb7..428536a 100644 --- a/src/unix/async.c +++ b/src/unix/async.c @@ -24,10 +24,10 @@ #include "uv.h" #include "internal.h" +#include "atomic-ops.h" #include "uv_log.h" #include -#include #include /* snprintf() */ #include #include @@ -54,7 +54,7 @@ int uv_async_init(uv_loop_t* loop, uv_async_t* handle, uv_async_cb async_cb) { handle->async_cb = async_cb; handle->pending = 0; - uv__queue_insert_tail(&loop->async_handles, &handle->queue); + QUEUE_INSERT_TAIL(&loop->async_handles, &handle->queue); uv__handle_start(handle); return 0; @@ -62,29 +62,23 @@ int uv_async_init(uv_loop_t* loop, uv_async_t* handle, uv_async_cb async_cb) { int uv_async_send(uv_async_t* handle) { - _Atomic int* pending; - - pending = (_Atomic int*) &handle->pending; - - /* Do a cheap read first. */ - if (atomic_load_explicit(pending, memory_order_relaxed) != 0) + if (ACCESS_ONCE(int, handle->pending) != 0) return 0; - /* Wake up the other thread's event loop. */ - if (atomic_exchange(pending, 1) != 0) + /* Tell the other thread we're busy with the handle. */ + if (cmpxchgi(&handle->pending, 0, 1) != 0) return 0; /* Wake up the other thread's event loop. */ uv__async_send(handle); + return 0; } - - void uv__async_close(uv_async_t* handle) { - atomic_exchange((_Atomic int*) &handle->pending, 0); - uv__queue_remove(&handle->queue); + cmpxchgi(&handle->pending, 1, 0); + QUEUE_REMOVE(&handle->queue); uv__handle_stop(handle); } @@ -92,10 +86,9 @@ void uv__async_close(uv_async_t* handle) { static void uv__async_io(uv_loop_t* loop, uv__io_t* w, unsigned int events) { char buf[1024]; ssize_t r; - struct uv__queue queue; - struct uv__queue* q; + QUEUE queue; + QUEUE* q; uv_async_t* h; - _Atomic int *pending; assert(w == &loop->async_io_watcher); @@ -122,18 +115,16 @@ static void uv__async_io(uv_loop_t* loop, uv__io_t* w, unsigned int events) { #endif } - uv__queue_move(&loop->async_handles, &queue); - while (!uv__queue_empty(&queue)) { - q = uv__queue_head(&queue); - h = uv__queue_data(q, uv_async_t, queue); + QUEUE_MOVE(&loop->async_handles, &queue); + while (!QUEUE_EMPTY(&queue)) { + q = QUEUE_HEAD(&queue); + h = QUEUE_DATA(q, uv_async_t, queue); - uv__queue_remove(q); - uv__queue_insert_tail(&loop->async_handles, q); + QUEUE_REMOVE(q); + QUEUE_INSERT_TAIL(&loop->async_handles, q); - /* Atomically fetch and clear pending flag */ - pending = (_Atomic int*) &h->pending; - if (atomic_exchange(pending, 0) == 0) - continue; + if (0 == cmpxchgi(&h->pending, 1, 0)) + continue; /* Not pending. */ if (h->async_cb == NULL) continue; @@ -148,8 +139,8 @@ static void uv__async_send(uv_async_t* handle) { ssize_t len; int fd; int r; - uv_loop_t* loop = handle->loop; + if (loop == NULL) { UV_LOGE("fatal error! loop is NULL"); return; @@ -170,7 +161,7 @@ static void uv__async_send(uv_async_t* handle) { do r = write(fd, buf, len); - while (r == -1 && errno == EINTR && atomic_load_explicit((_Atomic int*) &handle->pending, memory_order_relaxed) == 1); + while (r == -1 && errno == EINTR && ACCESS_ONCE(int, handle->pending) == 1); if (r == len) return; @@ -236,8 +227,8 @@ void uv__async_stop(uv_loop_t* loop) { if (loop->async_wfd != -1) { if (loop->async_wfd != loop->async_io_watcher.fd) { - UV_LOGI("close: loop addr is %{public}zu, loop->async_wfd is %{public}d", (size_t)loop, loop->async_wfd); uv__close(loop->async_wfd); + UV_LOGI("close: loop addr is %{public}zu, loop->async_wfd is %{public}d", (size_t)loop, loop->async_wfd); } loop->async_wfd = -1; } @@ -252,4 +243,3 @@ void uv__async_stop(uv_loop_t* loop) { (size_t)loop, loop->async_io_watcher.fd); loop->async_io_watcher.fd = -1; } - diff --git a/src/unix/atomic-ops.h b/src/unix/atomic-ops.h new file mode 100644 index 0000000..58043c4 --- /dev/null +++ b/src/unix/atomic-ops.h @@ -0,0 +1,64 @@ +/* Copyright (c) 2013, Ben Noordhuis + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#ifndef UV_ATOMIC_OPS_H_ +#define UV_ATOMIC_OPS_H_ + +#include "internal.h" /* UV_UNUSED */ + +#if defined(__SUNPRO_C) || defined(__SUNPRO_CC) +#include +#endif + +UV_UNUSED(static int cmpxchgi(int* ptr, int oldval, int newval)); +UV_UNUSED(static void cpu_relax(void)); + +/* Prefer hand-rolled assembly over the gcc builtins because the latter also + * issue full memory barriers. + */ +UV_UNUSED(static int cmpxchgi(int* ptr, int oldval, int newval)) { +#if defined(__i386__) || defined(__x86_64__) + int out; + __asm__ __volatile__ ("lock; cmpxchg %2, %1;" + : "=a" (out), "+m" (*(volatile int*) ptr) + : "r" (newval), "0" (oldval) + : "memory"); + return out; +#elif defined(__MVS__) + /* Use hand-rolled assembly because codegen from builtin __plo_CSST results in + * a runtime bug. + */ + __asm(" cs %0,%2,%1 \n " : "+r"(oldval), "+m"(*ptr) : "r"(newval) :); + return oldval; +#elif defined(__SUNPRO_C) || defined(__SUNPRO_CC) + return atomic_cas_uint((uint_t *)ptr, (uint_t)oldval, (uint_t)newval); +#else + return __sync_val_compare_and_swap(ptr, oldval, newval); +#endif +} + +UV_UNUSED(static void cpu_relax(void)) { +#if defined(__i386__) || defined(__x86_64__) + __asm__ __volatile__ ("rep; nop" ::: "memory"); /* a.k.a. PAUSE */ +#elif (defined(__arm__) && __ARM_ARCH >= 7) || defined(__aarch64__) + __asm__ __volatile__ ("yield" ::: "memory"); +#elif (defined(__ppc__) || defined(__ppc64__)) && defined(__APPLE__) + __asm volatile ("" : : : "memory"); +#elif !defined(__APPLE__) && (defined(__powerpc64__) || defined(__ppc64__) || defined(__PPC64__)) + __asm__ __volatile__ ("or 1,1,1; or 2,2,2" ::: "memory"); +#endif +} + +#endif /* UV_ATOMIC_OPS_H_ */ diff --git a/src/unix/core.c b/src/unix/core.c index 818c9fd..2cfa3e7 100644 --- a/src/unix/core.c +++ b/src/unix/core.c @@ -42,13 +42,12 @@ #include /* writev */ #include /* getrusage */ #include -#include #include #include -#include /* clock_gettime */ #ifdef __sun # include +# include # include #endif @@ -68,14 +67,13 @@ extern char** environ; #if defined(__DragonFly__) || \ defined(__FreeBSD__) || \ + defined(__FreeBSD_kernel__) || \ defined(__NetBSD__) || \ defined(__OpenBSD__) # include # include # include -# include # if defined(__FreeBSD__) -# include # define uv__accept4 accept4 # endif # if defined(__NetBSD__) @@ -91,7 +89,6 @@ extern char** environ; #if defined(__linux__) # include # include -# define gettid() syscall(SYS_gettid) # define uv__accept4 accept4 #endif @@ -111,35 +108,6 @@ STATIC_ASSERT(offsetof(uv_buf_t, base) == offsetof(struct iovec, iov_base)); STATIC_ASSERT(offsetof(uv_buf_t, len) == offsetof(struct iovec, iov_len)); -/* https://github.com/libuv/libuv/issues/1674 */ -int uv_clock_gettime(uv_clock_id clock_id, uv_timespec64_t* ts) { - struct timespec t; - int r; - - if (ts == NULL) - return UV_EFAULT; - - switch (clock_id) { - default: - return UV_EINVAL; - case UV_CLOCK_MONOTONIC: - r = clock_gettime(CLOCK_MONOTONIC, &t); - break; - case UV_CLOCK_REALTIME: - r = clock_gettime(CLOCK_REALTIME, &t); - break; - } - - if (r) - return UV__ERR(errno); - - ts->tv_sec = t.tv_sec; - ts->tv_nsec = t.tv_nsec; - - return 0; -} - - uint64_t uv_hrtime(void) { return uv__hrtime(UV_CLOCK_PRECISE); } @@ -265,10 +233,10 @@ int uv__getiovmax(void) { #if defined(IOV_MAX) return IOV_MAX; #elif defined(_SC_IOV_MAX) - static _Atomic int iovmax_cached = -1; + static int iovmax_cached = -1; int iovmax; - iovmax = atomic_load_explicit(&iovmax_cached, memory_order_relaxed); + iovmax = uv__load_relaxed(&iovmax_cached); if (iovmax != -1) return iovmax; @@ -280,7 +248,7 @@ int uv__getiovmax(void) { if (iovmax == -1) iovmax = 1; - atomic_store_explicit(&iovmax_cached, iovmax, memory_order_relaxed); + uv__store_relaxed(&iovmax_cached, iovmax); return iovmax; #else @@ -346,7 +314,7 @@ static void uv__finish_close(uv_handle_t* handle) { } uv__handle_unref(handle); - uv__queue_remove(&handle->handle_queue); + QUEUE_REMOVE(&handle->handle_queue); if (handle->close_cb) { handle->close_cb(handle); @@ -382,7 +350,7 @@ int uv_backend_fd(const uv_loop_t* loop) { static int uv__loop_alive(const uv_loop_t* loop) { return uv__has_active_handles(loop) || uv__has_active_reqs(loop) || - !uv__queue_empty(&loop->pending_queue) || + !QUEUE_EMPTY(&loop->pending_queue) || loop->closing_handles != NULL; } @@ -391,9 +359,8 @@ static int uv__backend_timeout(const uv_loop_t* loop) { if (loop->stop_flag == 0 && /* uv__loop_alive(loop) && */ (uv__has_active_handles(loop) || uv__has_active_reqs(loop)) && - uv__queue_empty(&loop->pending_queue) && - uv__queue_empty(&loop->idle_handles) && - (loop->flags & UV_LOOP_REAP_CHILDREN) == 0 && + QUEUE_EMPTY(&loop->pending_queue) && + QUEUE_EMPTY(&loop->idle_handles) && loop->closing_handles == NULL) return uv__next_timeout(loop); return 0; @@ -401,7 +368,7 @@ static int uv__backend_timeout(const uv_loop_t* loop) { int uv_backend_timeout(const uv_loop_t* loop) { - if (uv__queue_empty(&loop->watcher_queue)) + if (QUEUE_EMPTY(&loop->watcher_queue)) return uv__backend_timeout(loop); /* Need to call uv_run to update the backend fd state. */ return 0; @@ -416,7 +383,7 @@ int uv_loop_alive(const uv_loop_t* loop) { int uv_loop_alive_taskpool(const uv_loop_t* loop, int initial_handles) { return loop->active_handles > initial_handles || uv__has_active_reqs(loop) || - !uv__queue_empty(&loop->pending_queue) || + !QUEUE_EMPTY(&loop->pending_queue) || loop->closing_handles != NULL; } @@ -437,23 +404,16 @@ int uv_run(uv_loop_t* loop, uv_run_mode mode) { if (!r) uv__update_time(loop); - /* Maintain backwards compatibility by processing timers before entering the - * while loop for UV_RUN_DEFAULT. Otherwise timers only need to be executed - * once, which should be done after polling in order to maintain proper - * execution order of the conceptual event loop. */ - if (mode == UV_RUN_DEFAULT && r != 0 && loop->stop_flag == 0) { - uv__update_time(loop); - uv__run_timers(loop); - } - while (r != 0 && loop->stop_flag == 0) { if (!is_uv_loop_good_magic(loop)) { return 0; } + uv__update_time(loop); + uv__run_timers(loop); + can_sleep = - uv__queue_empty(&loop->pending_queue) && - uv__queue_empty(&loop->idle_handles); + QUEUE_EMPTY(&loop->pending_queue) && QUEUE_EMPTY(&loop->idle_handles); uv__run_pending(loop); uv__run_idle(loop); @@ -463,13 +423,11 @@ int uv_run(uv_loop_t* loop, uv_run_mode mode) { if ((mode == UV_RUN_ONCE && can_sleep) || mode == UV_RUN_DEFAULT) timeout = uv__backend_timeout(loop); - uv__metrics_inc_loop_count(loop); - uv__io_poll(loop, timeout); /* Process immediate callbacks (e.g. write_cb) a small fixed number of * times to avoid loop starvation.*/ - for (r = 0; r < 8 && !uv__queue_empty(&loop->pending_queue); r++) + for (r = 0; r < 8 && !QUEUE_EMPTY(&loop->pending_queue); r++) uv__run_pending(loop); /* Run one final update on the provider_idle_time in case uv__io_poll @@ -482,8 +440,18 @@ int uv_run(uv_loop_t* loop, uv_run_mode mode) { uv__run_check(loop); uv__run_closing_handles(loop); - uv__update_time(loop); - uv__run_timers(loop); + if (mode == UV_RUN_ONCE) { + /* UV_RUN_ONCE implies forward progress: at least one callback must have + * been invoked when it returns. uv__io_poll() can return without doing + * I/O (meaning: no callbacks) when its timeout expires - which means we + * have pending timers that satisfy the forward progress constraint. + * + * UV_RUN_NOWAIT makes no guarantees about progress so it's omitted from + * the check. + */ + uv__update_time(loop); + uv__run_timers(loop); + } r = uv__loop_alive(loop); if (mode == UV_RUN_ONCE || mode == UV_RUN_NOWAIT) @@ -848,17 +816,17 @@ int uv_fileno(const uv_handle_t* handle, uv_os_fd_t* fd) { static void uv__run_pending(uv_loop_t* loop) { - struct uv__queue* q; - struct uv__queue pq; + QUEUE* q; + QUEUE pq; uv__io_t* w; - uv__queue_move(&loop->pending_queue, &pq); + QUEUE_MOVE(&loop->pending_queue, &pq); - while (!uv__queue_empty(&pq)) { - q = uv__queue_head(&pq); - uv__queue_remove(q); - uv__queue_init(q); - w = uv__queue_data(q, uv__io_t, pending_queue); + while (!QUEUE_EMPTY(&pq)) { + q = QUEUE_HEAD(&pq); + QUEUE_REMOVE(q); + QUEUE_INIT(q); + w = QUEUE_DATA(q, uv__io_t, pending_queue); w->cb(loop, w, POLLOUT); } } @@ -913,12 +881,17 @@ static void maybe_resize(uv_loop_t* loop, unsigned int len) { void uv__io_init(uv__io_t* w, uv__io_cb cb, int fd) { assert(cb != NULL); assert(fd >= -1); - uv__queue_init(&w->pending_queue); - uv__queue_init(&w->watcher_queue); + QUEUE_INIT(&w->pending_queue); + QUEUE_INIT(&w->watcher_queue); w->cb = cb; w->fd = fd; w->events = 0; w->pevents = 0; + +#if defined(UV_HAVE_KQUEUE) + w->rcount = 0; + w->wcount = 0; +#endif /* defined(UV_HAVE_KQUEUE) */ } @@ -940,8 +913,8 @@ void uv__io_start(uv_loop_t* loop, uv__io_t* w, unsigned int events) { return; #endif - if (uv__queue_empty(&w->watcher_queue)) - uv__queue_insert_tail(&loop->watcher_queue, &w->watcher_queue); + if (QUEUE_EMPTY(&w->watcher_queue)) + QUEUE_INSERT_TAIL(&loop->watcher_queue, &w->watcher_queue); if (loop->watchers[w->fd] == NULL) { loop->watchers[w->fd] = w; @@ -966,8 +939,8 @@ void uv__io_stop(uv_loop_t* loop, uv__io_t* w, unsigned int events) { w->pevents &= ~events; if (w->pevents == 0) { - uv__queue_remove(&w->watcher_queue); - uv__queue_init(&w->watcher_queue); + QUEUE_REMOVE(&w->watcher_queue); + QUEUE_INIT(&w->watcher_queue); w->events = 0; if (w == loop->watchers[w->fd]) { @@ -976,14 +949,14 @@ void uv__io_stop(uv_loop_t* loop, uv__io_t* w, unsigned int events) { loop->nfds--; } } - else if (uv__queue_empty(&w->watcher_queue)) - uv__queue_insert_tail(&loop->watcher_queue, &w->watcher_queue); + else if (QUEUE_EMPTY(&w->watcher_queue)) + QUEUE_INSERT_TAIL(&loop->watcher_queue, &w->watcher_queue); } void uv__io_close(uv_loop_t* loop, uv__io_t* w) { uv__io_stop(loop, w, POLLIN | POLLOUT | UV__POLLRDHUP | UV__POLLPRI); - uv__queue_remove(&w->pending_queue); + QUEUE_REMOVE(&w->pending_queue); /* Remove stale events for this file descriptor */ if (w->fd != -1) @@ -992,8 +965,8 @@ void uv__io_close(uv_loop_t* loop, uv__io_t* w) { void uv__io_feed(uv_loop_t* loop, uv__io_t* w) { - if (uv__queue_empty(&w->pending_queue)) - uv__queue_insert_tail(&loop->pending_queue, &w->pending_queue); + if (QUEUE_EMPTY(&w->pending_queue)) + QUEUE_INSERT_TAIL(&loop->pending_queue, &w->pending_queue); } @@ -1038,15 +1011,6 @@ int uv_getrusage(uv_rusage_t* rusage) { rusage->ru_nivcsw = usage.ru_nivcsw; #endif - /* Most platforms report ru_maxrss in kilobytes; macOS and Solaris are - * the outliers because of course they are. - */ -#if defined(__APPLE__) - rusage->ru_maxrss /= 1024; /* macOS and iOS report bytes. */ -#elif defined(__sun) - rusage->ru_maxrss /= getpagesize() / 1024; /* Solaris reports pages. */ -#endif - return 0; } @@ -1146,8 +1110,8 @@ int uv_os_homedir(char* buffer, size_t* size) { if (r != UV_ENOENT) return r; - /* HOME is not set, so call uv_os_get_passwd() */ - r = uv_os_get_passwd(&pwd); + /* HOME is not set, so call uv__getpwuid_r() */ + r = uv__getpwuid_r(&pwd); if (r != 0) { return r; @@ -1220,10 +1184,11 @@ return_buffer: } -static int uv__getpwuid_r(uv_passwd_t *pwd, uid_t uid) { +int uv__getpwuid_r(uv_passwd_t* pwd) { struct passwd pw; struct passwd* result; char* buf; + uid_t uid; size_t bufsize; size_t name_size; size_t homedir_size; @@ -1233,6 +1198,8 @@ static int uv__getpwuid_r(uv_passwd_t *pwd, uid_t uid) { if (pwd == NULL) return UV_EINVAL; + uid = geteuid(); + /* Calling sysconf(_SC_GETPW_R_SIZE_MAX) would get the suggested size, but it * is frequently 1024 or 4096, so we can just use that directly. The pwent * will not usually be large. */ @@ -1291,98 +1258,24 @@ static int uv__getpwuid_r(uv_passwd_t *pwd, uid_t uid) { } -int uv_os_get_group(uv_group_t* grp, uv_uid_t gid) { -#if defined(__ANDROID__) && __ANDROID_API__ < 24 - /* This function getgrgid_r() was added in Android N (level 24) */ - return UV_ENOSYS; -#else - struct group gp; - struct group* result; - char* buf; - char* gr_mem; - size_t bufsize; - size_t name_size; - long members; - size_t mem_size; - int r; - - if (grp == NULL) - return UV_EINVAL; - - /* Calling sysconf(_SC_GETGR_R_SIZE_MAX) would get the suggested size, but it - * is frequently 1024 or 4096, so we can just use that directly. The pwent - * will not usually be large. */ - for (bufsize = 2000;; bufsize *= 2) { - buf = uv__malloc(bufsize); - - if (buf == NULL) - return UV_ENOMEM; - - do - r = getgrgid_r(gid, &gp, buf, bufsize, &result); - while (r == EINTR); - - if (r != 0 || result == NULL) - uv__free(buf); - - if (r != ERANGE) - break; - } - - if (r != 0) - return UV__ERR(r); - - if (result == NULL) - return UV_ENOENT; - - /* Allocate memory for the groupname and members. */ - name_size = strlen(gp.gr_name) + 1; - members = 0; - mem_size = sizeof(char*); - for (r = 0; gp.gr_mem[r] != NULL; r++) { - mem_size += strlen(gp.gr_mem[r]) + 1 + sizeof(char*); - members++; - } - - gr_mem = uv__malloc(name_size + mem_size); - if (gr_mem == NULL) { - uv__free(buf); - return UV_ENOMEM; - } - - /* Copy the members */ - grp->members = (char**) gr_mem; - grp->members[members] = NULL; - gr_mem = (char*) &grp->members[members + 1]; - for (r = 0; r < members; r++) { - grp->members[r] = gr_mem; - strcpy(gr_mem, gp.gr_mem[r]); - gr_mem += strlen(gr_mem) + 1; - } - assert(gr_mem == (char*)grp->members + mem_size); - - /* Copy the groupname */ - grp->groupname = gr_mem; - memcpy(grp->groupname, gp.gr_name, name_size); - gr_mem += name_size; - - /* Copy the gid */ - grp->gid = gp.gr_gid; - - uv__free(buf); +void uv_os_free_passwd(uv_passwd_t* pwd) { + if (pwd == NULL) + return; - return 0; -#endif + /* + The memory for name, shell, and homedir are allocated in a single + uv__malloc() call. The base of the pointer is stored in pwd->username, so + that is the field that needs to be freed. + */ + uv__free(pwd->username); + pwd->username = NULL; + pwd->shell = NULL; + pwd->homedir = NULL; } int uv_os_get_passwd(uv_passwd_t* pwd) { - return uv__getpwuid_r(pwd, geteuid()); -} - - -int uv_os_get_passwd2(uv_passwd_t* pwd, uv_uid_t uid) { - return uv__getpwuid_r(pwd, uid); + return uv__getpwuid_r(pwd); } @@ -1543,13 +1436,6 @@ uv_pid_t uv_os_getppid(void) { return getppid(); } -int uv_cpumask_size(void) { -#if UV__CPU_AFFINITY_SUPPORTED - return CPU_SETSIZE; -#else - return UV_ENOTSUP; -#endif -} int uv_os_getpriority(uv_pid_t pid, int* priority) { int r; @@ -1578,130 +1464,6 @@ int uv_os_setpriority(uv_pid_t pid, int priority) { return 0; } -/** - * If the function succeeds, the return value is 0. - * If the function fails, the return value is non-zero. - * for Linux, when schedule policy is SCHED_OTHER (default), priority is 0. - * So the output parameter priority is actually the nice value. -*/ -int uv_thread_getpriority(uv_thread_t tid, int* priority) { - int r; - int policy; - struct sched_param param; -#ifdef __linux__ - pid_t pid = gettid(); -#endif - - if (priority == NULL) - return UV_EINVAL; - - r = pthread_getschedparam(tid, &policy, ¶m); - if (r != 0) - return UV__ERR(errno); - -#ifdef __linux__ - if (SCHED_OTHER == policy && pthread_equal(tid, pthread_self())) { - errno = 0; - r = getpriority(PRIO_PROCESS, pid); - if (r == -1 && errno != 0) - return UV__ERR(errno); - *priority = r; - return 0; - } -#endif - - *priority = param.sched_priority; - return 0; -} - -#ifdef __linux__ -static int set_nice_for_calling_thread(int priority) { - int r; - int nice; - - if (priority < UV_THREAD_PRIORITY_LOWEST || priority > UV_THREAD_PRIORITY_HIGHEST) - return UV_EINVAL; - - pid_t pid = gettid(); - nice = 0 - priority * 2; - r = setpriority(PRIO_PROCESS, pid, nice); - if (r != 0) - return UV__ERR(errno); - return 0; -} -#endif - -/** - * If the function succeeds, the return value is 0. - * If the function fails, the return value is non-zero. -*/ -int uv_thread_setpriority(uv_thread_t tid, int priority) { - int r; - int min; - int max; - int range; - int prio; - int policy; - struct sched_param param; - - if (priority < UV_THREAD_PRIORITY_LOWEST || priority > UV_THREAD_PRIORITY_HIGHEST) - return UV_EINVAL; - - r = pthread_getschedparam(tid, &policy, ¶m); - if (r != 0) - return UV__ERR(errno); - -#ifdef __linux__ -/** - * for Linux, when schedule policy is SCHED_OTHER (default), priority must be 0, - * we should set the nice value in this case. -*/ - if (SCHED_OTHER == policy && pthread_equal(tid, pthread_self())) - return set_nice_for_calling_thread(priority); -#endif - -#ifdef __PASE__ - min = 1; - max = 127; -#else - min = sched_get_priority_min(policy); - max = sched_get_priority_max(policy); -#endif - - if (min == -1 || max == -1) - return UV__ERR(errno); - - range = max - min; - - switch (priority) { - case UV_THREAD_PRIORITY_HIGHEST: - prio = max; - break; - case UV_THREAD_PRIORITY_ABOVE_NORMAL: - prio = min + range * 3 / 4; - break; - case UV_THREAD_PRIORITY_NORMAL: - prio = min + range / 2; - break; - case UV_THREAD_PRIORITY_BELOW_NORMAL: - prio = min + range / 4; - break; - case UV_THREAD_PRIORITY_LOWEST: - prio = min; - break; - default: - return 0; - } - - if (param.sched_priority != prio) { - param.sched_priority = prio; - r = pthread_setschedparam(tid, policy, ¶m); - if (r != 0) - return UV__ERR(errno); - } - - return 0; -} int uv_os_uname(uv_utsname_t* buffer) { struct utsname buf; diff --git a/src/unix/cygwin.c b/src/unix/cygwin.c index 4e54139..169958d 100644 --- a/src/unix/cygwin.c +++ b/src/unix/cygwin.c @@ -51,7 +51,3 @@ int uv_cpu_info(uv_cpu_info_t** cpu_infos, int* count) { uint64_t uv_get_constrained_memory(void) { return 0; /* Memory constraints are unknown. */ } - -uint64_t uv_get_available_memory(void) { - return uv_get_free_memory(); -} diff --git a/src/unix/darwin-stub.h b/src/unix/darwin-stub.h index b93cf67..433e3ef 100644 --- a/src/unix/darwin-stub.h +++ b/src/unix/darwin-stub.h @@ -27,6 +27,7 @@ struct CFArrayCallBacks; struct CFRunLoopSourceContext; struct FSEventStreamContext; +struct CFRange; typedef double CFAbsoluteTime; typedef double CFTimeInterval; @@ -42,13 +43,23 @@ typedef unsigned CFStringEncoding; typedef void* CFAllocatorRef; typedef void* CFArrayRef; typedef void* CFBundleRef; +typedef void* CFDataRef; typedef void* CFDictionaryRef; +typedef void* CFMutableDictionaryRef; +typedef struct CFRange CFRange; typedef void* CFRunLoopRef; typedef void* CFRunLoopSourceRef; typedef void* CFStringRef; typedef void* CFTypeRef; typedef void* FSEventStreamRef; +typedef uint32_t IOOptionBits; +typedef unsigned int io_iterator_t; +typedef unsigned int io_object_t; +typedef unsigned int io_service_t; +typedef unsigned int io_registry_entry_t; + + typedef void (*FSEventStreamCallback)(const FSEventStreamRef, void*, size_t, @@ -69,6 +80,11 @@ struct FSEventStreamContext { void* pad[3]; }; +struct CFRange { + CFIndex location; + CFIndex length; +}; + static const CFStringEncoding kCFStringEncodingUTF8 = 0x8000100; static const OSStatus noErr = 0; diff --git a/src/unix/darwin.c b/src/unix/darwin.c index 5e764a6..62f04d3 100644 --- a/src/unix/darwin.c +++ b/src/unix/darwin.c @@ -33,10 +33,13 @@ #include #include /* sysconf */ +#include "darwin-stub.h" + static uv_once_t once = UV_ONCE_INIT; static uint64_t (*time_func)(void); static mach_timebase_info_data_t timebase; +typedef unsigned char UInt8; int uv__platform_loop_init(uv_loop_t* loop) { loop->cf_state = NULL; @@ -107,7 +110,7 @@ uint64_t uv_get_free_memory(void) { if (host_statistics(mach_host_self(), HOST_VM_INFO, (host_info_t)&info, &count) != KERN_SUCCESS) { - return 0; + return UV_EINVAL; /* FIXME(bnoordhuis) Translate error. */ } return (uint64_t) info.free_count * sysconf(_SC_PAGESIZE); @@ -120,7 +123,7 @@ uint64_t uv_get_total_memory(void) { size_t size = sizeof(info); if (sysctl(which, ARRAY_SIZE(which), &info, &size, NULL, 0)) - return 0; + return UV__ERR(errno); return (uint64_t) info; } @@ -131,11 +134,6 @@ uint64_t uv_get_constrained_memory(void) { } -uint64_t uv_get_available_memory(void) { - return uv_get_free_memory(); -} - - void uv_loadavg(double avg[3]) { struct loadavg info; size_t size = sizeof(info); @@ -185,17 +183,159 @@ int uv_uptime(double* uptime) { return 0; } +static int uv__get_cpu_speed(uint64_t* speed) { + /* IOKit */ + void (*pIOObjectRelease)(io_object_t); + kern_return_t (*pIOMasterPort)(mach_port_t, mach_port_t*); + CFMutableDictionaryRef (*pIOServiceMatching)(const char*); + kern_return_t (*pIOServiceGetMatchingServices)(mach_port_t, + CFMutableDictionaryRef, + io_iterator_t*); + io_service_t (*pIOIteratorNext)(io_iterator_t); + CFTypeRef (*pIORegistryEntryCreateCFProperty)(io_registry_entry_t, + CFStringRef, + CFAllocatorRef, + IOOptionBits); + + /* CoreFoundation */ + CFStringRef (*pCFStringCreateWithCString)(CFAllocatorRef, + const char*, + CFStringEncoding); + CFStringEncoding (*pCFStringGetSystemEncoding)(void); + UInt8 *(*pCFDataGetBytePtr)(CFDataRef); + CFIndex (*pCFDataGetLength)(CFDataRef); + void (*pCFDataGetBytes)(CFDataRef, CFRange, UInt8*); + void (*pCFRelease)(CFTypeRef); + + void* core_foundation_handle; + void* iokit_handle; + int err; + + kern_return_t kr; + mach_port_t mach_port; + io_iterator_t it; + io_object_t service; + + mach_port = 0; + + err = UV_ENOENT; + core_foundation_handle = dlopen("/System/Library/Frameworks/" + "CoreFoundation.framework/" + "CoreFoundation", + RTLD_LAZY | RTLD_LOCAL); + iokit_handle = dlopen("/System/Library/Frameworks/IOKit.framework/" + "IOKit", + RTLD_LAZY | RTLD_LOCAL); + + if (core_foundation_handle == NULL || iokit_handle == NULL) + goto out; + +#define V(handle, symbol) \ + do { \ + *(void **)(&p ## symbol) = dlsym((handle), #symbol); \ + if (p ## symbol == NULL) \ + goto out; \ + } \ + while (0) + V(iokit_handle, IOMasterPort); + V(iokit_handle, IOServiceMatching); + V(iokit_handle, IOServiceGetMatchingServices); + V(iokit_handle, IOIteratorNext); + V(iokit_handle, IOObjectRelease); + V(iokit_handle, IORegistryEntryCreateCFProperty); + V(core_foundation_handle, CFStringCreateWithCString); + V(core_foundation_handle, CFStringGetSystemEncoding); + V(core_foundation_handle, CFDataGetBytePtr); + V(core_foundation_handle, CFDataGetLength); + V(core_foundation_handle, CFDataGetBytes); + V(core_foundation_handle, CFRelease); +#undef V + +#define S(s) pCFStringCreateWithCString(NULL, (s), kCFStringEncodingUTF8) + + kr = pIOMasterPort(MACH_PORT_NULL, &mach_port); + assert(kr == KERN_SUCCESS); + CFMutableDictionaryRef classes_to_match + = pIOServiceMatching("IOPlatformDevice"); + kr = pIOServiceGetMatchingServices(mach_port, classes_to_match, &it); + assert(kr == KERN_SUCCESS); + service = pIOIteratorNext(it); + + CFStringRef device_type_str = S("device_type"); + CFStringRef clock_frequency_str = S("clock-frequency"); + + while (service != 0) { + CFDataRef data; + data = pIORegistryEntryCreateCFProperty(service, + device_type_str, + NULL, + 0); + if (data) { + const UInt8* raw = pCFDataGetBytePtr(data); + if (strncmp((char*)raw, "cpu", 3) == 0 || + strncmp((char*)raw, "processor", 9) == 0) { + CFDataRef freq_ref; + freq_ref = pIORegistryEntryCreateCFProperty(service, + clock_frequency_str, + NULL, + 0); + if (freq_ref) { + const UInt8* freq_ref_ptr = pCFDataGetBytePtr(freq_ref); + CFIndex len = pCFDataGetLength(freq_ref); + if (len == 8) + memcpy(speed, freq_ref_ptr, 8); + else if (len == 4) { + uint32_t v; + memcpy(&v, freq_ref_ptr, 4); + *speed = v; + } else { + *speed = 0; + } + + pCFRelease(freq_ref); + pCFRelease(data); + break; + } + } + pCFRelease(data); + } + + service = pIOIteratorNext(it); + } + + pIOObjectRelease(it); + + err = 0; + + if (device_type_str != NULL) + pCFRelease(device_type_str); + if (clock_frequency_str != NULL) + pCFRelease(clock_frequency_str); + +out: + if (core_foundation_handle != NULL) + dlclose(core_foundation_handle); + + if (iokit_handle != NULL) + dlclose(iokit_handle); + + mach_port_deallocate(mach_task_self(), mach_port); + + return err; +} + int uv_cpu_info(uv_cpu_info_t** cpu_infos, int* count) { unsigned int ticks = (unsigned int)sysconf(_SC_CLK_TCK), multiplier = ((uint64_t)1000L / ticks); char model[512]; - uint64_t cpuspeed; size_t size; unsigned int i; natural_t numcpus; mach_msg_type_number_t msg_type; processor_cpu_load_info_data_t *info; uv_cpu_info_t* cpu_info; + uint64_t cpuspeed; + int err; size = sizeof(model); if (sysctlbyname("machdep.cpu.brand_string", &model, &size, NULL, 0) && @@ -203,13 +343,9 @@ int uv_cpu_info(uv_cpu_info_t** cpu_infos, int* count) { return UV__ERR(errno); } - cpuspeed = 0; - size = sizeof(cpuspeed); - sysctlbyname("hw.cpufrequency", &cpuspeed, &size, NULL, 0); - if (cpuspeed == 0) - /* If sysctl hw.cputype == CPU_TYPE_ARM64, the correct value is unavailable - * from Apple, but we can hard-code it here to a plausible value. */ - cpuspeed = 2400000000U; + err = uv__get_cpu_speed(&cpuspeed); + if (err < 0) + return err; if (host_processor_info(mach_host_self(), PROCESSOR_CPU_LOAD_INFO, &numcpus, (processor_info_array_t*)&info, @@ -235,7 +371,7 @@ int uv_cpu_info(uv_cpu_info_t** cpu_infos, int* count) { cpu_info->cpu_times.irq = 0; cpu_info->model = uv__strdup(model); - cpu_info->speed = (int)(cpuspeed / 1000000); + cpu_info->speed = cpuspeed/1000000; } vm_deallocate(mach_task_self(), (vm_address_t)info, msg_type); diff --git a/src/unix/epoll.c b/src/unix/epoll.c new file mode 100644 index 0000000..c906609 --- /dev/null +++ b/src/unix/epoll.c @@ -0,0 +1,472 @@ +/* Copyright libuv contributors. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to + * deal in the Software without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS + * IN THE SOFTWARE. + */ + +#include "uv.h" +#include "uv_log.h" +#include "internal.h" +#include +#include +#include +#ifdef USE_FFRT +#include "ffrt.h" +#include "c/executor_task.h" + +int uv__epoll_wait(struct epoll_event* events, int eventsize, uint64_t timeout) { + int nfds = 0; + if (ffrt_get_cur_task() != NULL) { + ffrt_qos_t qos = ffrt_this_task_get_qos(); + nfds = ffrt_epoll_wait(qos, events, eventsize, timeout); + } + return nfds; +} +#endif + +int uv__epoll_ctl(int epoll_fd, int op, int fd, struct epoll_event* event) { +#ifdef USE_FFRT + if (ffrt_get_cur_task() != NULL) { + ffrt_qos_t qos = ffrt_this_task_get_qos(); + return ffrt_epoll_ctl(qos, op, fd, event->events, NULL, NULL); + } +#endif + return epoll_ctl(epoll_fd, op, fd ,event); +} + +int uv__epoll_init(uv_loop_t* loop) { + int fd; + fd = epoll_create1(O_CLOEXEC); + + /* epoll_create1() can fail either because it's not implemented (old kernel) + * or because it doesn't understand the O_CLOEXEC flag. + */ + if (fd == -1 && (errno == ENOSYS || errno == EINVAL)) { + fd = epoll_create(256); + + if (fd != -1) + uv__cloexec(fd, 1); + } + + loop->backend_fd = fd; +#ifdef USE_OHOS_DFX + fdsan_exchange_owner_tag(loop->backend_fd, 0, uv__get_addr_tag((void *)&loop->backend_fd)); +#endif + UV_LOGI("loop init: loop add is %{public}zu, backend_fd is %{public}d", (size_t)loop, fd); + if (fd == -1) + return UV__ERR(errno); + + return 0; +} + + +void uv__platform_invalidate_fd(uv_loop_t* loop, int fd) { + struct epoll_event* events; + struct epoll_event dummy; + uintptr_t i; + uintptr_t nfds; + + assert(loop->watchers != NULL); + assert(fd >= 0); + + events = (struct epoll_event*) loop->watchers[loop->nwatchers]; + nfds = (uintptr_t) loop->watchers[loop->nwatchers + 1]; + if (events != NULL) + /* Invalidate events with same file descriptor */ + for (i = 0; i < nfds; i++) + if (events[i].data.fd == fd) + events[i].data.fd = -1; + + /* Remove the file descriptor from the epoll. + * This avoids a problem where the same file description remains open + * in another process, causing repeated junk epoll events. + * + * We pass in a dummy epoll_event, to work around a bug in old kernels. + */ + if (loop->backend_fd >= 0) { + /* Work around a bug in kernels 3.10 to 3.19 where passing a struct that + * has the EPOLLWAKEUP flag set generates spurious audit syslog warnings. + */ + memset(&dummy, 0, sizeof(dummy)); + uv__epoll_ctl(loop->backend_fd, EPOLL_CTL_DEL, fd, &dummy); + } +} + + +int uv__io_check_fd(uv_loop_t* loop, int fd) { + struct epoll_event e; + int rc; + + memset(&e, 0, sizeof(e)); + e.events = POLLIN; + e.data.fd = -1; + + rc = 0; + if (uv__epoll_ctl(loop->backend_fd, EPOLL_CTL_ADD, fd, &e)) + if (errno != EEXIST) + rc = UV__ERR(errno); + + if (rc == 0) + if (uv__epoll_ctl(loop->backend_fd, EPOLL_CTL_DEL, fd, &e)) + abort(); + + return rc; +} + + +void uv__io_poll(uv_loop_t* loop, int timeout) { + /* A bug in kernels < 2.6.37 makes timeouts larger than ~30 minutes + * effectively infinite on 32 bits architectures. To avoid blocking + * indefinitely, we cap the timeout and poll again if necessary. + * + * Note that "30 minutes" is a simplification because it depends on + * the value of CONFIG_HZ. The magic constant assumes CONFIG_HZ=1200, + * that being the largest value I have seen in the wild (and only once.) + */ + static const int max_safe_timeout = 1789569; + static int no_epoll_pwait_cached; + static int no_epoll_wait_cached; + int no_epoll_pwait; + int no_epoll_wait; + struct epoll_event events[1024]; + struct epoll_event* pe; + struct epoll_event e; + int real_timeout; + QUEUE* q; + uv__io_t* w; + sigset_t sigset; + uint64_t sigmask; + uint64_t base; + int have_signals; + int nevents; + int count; + int nfds; + int fd; + int op; + int i; + int user_timeout; + int reset_timeout; + + if (loop->nfds == 0) { + assert(QUEUE_EMPTY(&loop->watcher_queue)); + return; + } + + memset(&e, 0, sizeof(e)); + + while (!QUEUE_EMPTY(&loop->watcher_queue)) { + q = QUEUE_HEAD(&loop->watcher_queue); + QUEUE_REMOVE(q); + QUEUE_INIT(q); + + w = QUEUE_DATA(q, uv__io_t, watcher_queue); + assert(w->pevents != 0); + assert(w->fd >= 0); + assert(w->fd < (int) loop->nwatchers); + + e.events = w->pevents; + e.data.fd = w->fd; + + if (w->events == 0) + op = EPOLL_CTL_ADD; + else + op = EPOLL_CTL_MOD; + + /* XXX Future optimization: do EPOLL_CTL_MOD lazily if we stop watching + * events, skip the syscall and squelch the events after epoll_wait(). + */ + if (uv__epoll_ctl(loop->backend_fd, op, w->fd, &e)) { + if (errno != EEXIST) +#ifdef PRINT_ERRNO_ABORT + UV_ERRNO_ABORT("errno is %d, loop addr is %zu, backend_fd is %d, fd is %d (%s:%s:%d)", + errno, (size_t)loop, loop->backend_fd, w->fd, __FILE__, __func__, __LINE__); +#else + abort(); +#endif + + assert(op == EPOLL_CTL_ADD); + + /* We've reactivated a file descriptor that's been watched before. */ + if (uv__epoll_ctl(loop->backend_fd, EPOLL_CTL_MOD, w->fd, &e)) +#ifdef PRINT_ERRNO_ABORT + UV_ERRNO_ABORT("errno is %d, loop addr is %zu, backend_fd is %d, fd is %d (%s:%s:%d)", + errno, (size_t)loop, loop->backend_fd, w->fd, __FILE__, __func__, __LINE__); +#else + abort(); +#endif + } + + w->events = w->pevents; + } + + sigmask = 0; + if (loop->flags & UV_LOOP_BLOCK_SIGPROF) { + sigemptyset(&sigset); + sigaddset(&sigset, SIGPROF); + sigmask |= 1 << (SIGPROF - 1); + } + + assert(timeout >= -1); + base = loop->time; + count = 48; /* Benchmarks suggest this gives the best throughput. */ + real_timeout = timeout; + + if (uv__get_internal_fields(loop)->flags & UV_METRICS_IDLE_TIME) { + reset_timeout = 1; + user_timeout = timeout; + timeout = 0; + } else { + reset_timeout = 0; + user_timeout = 0; + } + + /* You could argue there is a dependency between these two but + * ultimately we don't care about their ordering with respect + * to one another. Worst case, we make a few system calls that + * could have been avoided because another thread already knows + * they fail with ENOSYS. Hardly the end of the world. + */ + no_epoll_pwait = uv__load_relaxed(&no_epoll_pwait_cached); + no_epoll_wait = uv__load_relaxed(&no_epoll_wait_cached); + + for (;;) { + /* Only need to set the provider_entry_time if timeout != 0. The function + * will return early if the loop isn't configured with UV_METRICS_IDLE_TIME. + */ + if (timeout != 0) + uv__metrics_set_provider_entry_time(loop); + + /* See the comment for max_safe_timeout for an explanation of why + * this is necessary. Executive summary: kernel bug workaround. + */ + if (sizeof(int32_t) == sizeof(long) && timeout >= max_safe_timeout) + timeout = max_safe_timeout; + + if (sigmask != 0 && no_epoll_pwait != 0) + if (pthread_sigmask(SIG_BLOCK, &sigset, NULL)) + abort(); +#ifdef USE_FFRT + if (ffrt_get_cur_task() == NULL) { +#endif + if (no_epoll_wait != 0 || (sigmask != 0 && no_epoll_pwait == 0)) { + nfds = epoll_pwait(loop->backend_fd, + events, + ARRAY_SIZE(events), + timeout, + &sigset); + if (nfds == -1 && errno == ENOSYS) { + uv__store_relaxed(&no_epoll_pwait_cached, 1); + no_epoll_pwait = 1; + } + } else { + nfds = epoll_wait(loop->backend_fd, + events, + ARRAY_SIZE(events), + timeout); + if (nfds == -1 && errno == ENOSYS) { + uv__store_relaxed(&no_epoll_wait_cached, 1); + no_epoll_wait = 1; + } + } +#ifdef USE_FFRT + } else { + nfds = uv__epoll_wait(events, ARRAY_SIZE(events), timeout); + } +#endif + if (sigmask != 0 && no_epoll_pwait != 0) + if (pthread_sigmask(SIG_UNBLOCK, &sigset, NULL)) + abort(); + + /* Update loop->time unconditionally. It's tempting to skip the update when + * timeout == 0 (i.e. non-blocking poll) but there is no guarantee that the + * operating system didn't reschedule our process while in the syscall. + */ + SAVE_ERRNO(uv__update_time(loop)); + + if (nfds == 0) { + assert(timeout != -1); + + if (reset_timeout != 0) { + timeout = user_timeout; + reset_timeout = 0; + } + + if (timeout == -1) + continue; + + if (timeout == 0) + return; + + /* We may have been inside the system call for longer than |timeout| + * milliseconds so we need to update the timestamp to avoid drift. + */ + goto update_timeout; + } + + if (nfds == -1) { + if (errno == ENOSYS) { + /* epoll_wait() or epoll_pwait() failed, try the other system call. */ + assert(no_epoll_wait == 0 || no_epoll_pwait == 0); + continue; + } + + if (errno != EINTR) +#ifdef PRINT_ERRNO_ABORT + UV_ERRNO_ABORT("errno is %d, loop addr is %zu, backend_fd is %d (%s:%s:%d)", + errno, (size_t)loop, loop->backend_fd, __FILE__, __func__, __LINE__); +#else + abort(); +#endif + + if (reset_timeout != 0) { + timeout = user_timeout; + reset_timeout = 0; + } + + if (timeout == -1) + continue; + + if (timeout == 0) + return; + + /* Interrupted by a signal. Update timeout and poll again. */ + goto update_timeout; + } + + have_signals = 0; + nevents = 0; + + { + /* Squelch a -Waddress-of-packed-member warning with gcc >= 9. */ + union { + struct epoll_event* events; + uv__io_t* watchers; + } x; + + x.events = events; + assert(loop->watchers != NULL); + loop->watchers[loop->nwatchers] = x.watchers; + loop->watchers[loop->nwatchers + 1] = (void*) (uintptr_t) nfds; + } + + for (i = 0; i < nfds; i++) { + pe = events + i; + fd = pe->data.fd; + + /* Skip invalidated events, see uv__platform_invalidate_fd */ + if (fd == -1) + continue; + + assert(fd >= 0); + assert((unsigned) fd < loop->nwatchers); + + w = loop->watchers[fd]; + + if (w == NULL) { + /* File descriptor that we've stopped watching, disarm it. + * + * Ignore all errors because we may be racing with another thread + * when the file descriptor is closed. + */ + uv__epoll_ctl(loop->backend_fd, EPOLL_CTL_DEL, fd, pe); + continue; + } + + /* Give users only events they're interested in. Prevents spurious + * callbacks when previous callback invocation in this loop has stopped + * the current watcher. Also, filters out events that users has not + * requested us to watch. + */ + pe->events &= w->pevents | POLLERR | POLLHUP; + + /* Work around an epoll quirk where it sometimes reports just the + * EPOLLERR or EPOLLHUP event. In order to force the event loop to + * move forward, we merge in the read/write events that the watcher + * is interested in; uv__read() and uv__write() will then deal with + * the error or hangup in the usual fashion. + * + * Note to self: happens when epoll reports EPOLLIN|EPOLLHUP, the user + * reads the available data, calls uv_read_stop(), then sometime later + * calls uv_read_start() again. By then, libuv has forgotten about the + * hangup and the kernel won't report EPOLLIN again because there's + * nothing left to read. If anything, libuv is to blame here. The + * current hack is just a quick bandaid; to properly fix it, libuv + * needs to remember the error/hangup event. We should get that for + * free when we switch over to edge-triggered I/O. + */ + if (pe->events == POLLERR || pe->events == POLLHUP) + pe->events |= + w->pevents & (POLLIN | POLLOUT | UV__POLLRDHUP | UV__POLLPRI); + + if (pe->events != 0) { + /* Run signal watchers last. This also affects child process watchers + * because those are implemented in terms of signal watchers. + */ + if (w == &loop->signal_io_watcher) { + have_signals = 1; + } else { + uv__metrics_update_idle_time(loop); + w->cb(loop, w, pe->events); + } + + nevents++; + } + } + + if (reset_timeout != 0) { + timeout = user_timeout; + reset_timeout = 0; + } + + if (have_signals != 0) { + uv__metrics_update_idle_time(loop); + loop->signal_io_watcher.cb(loop, &loop->signal_io_watcher, POLLIN); + } + + loop->watchers[loop->nwatchers] = NULL; + loop->watchers[loop->nwatchers + 1] = NULL; + + if (have_signals != 0) + return; /* Event loop should cycle now so don't poll again. */ + + if (nevents != 0) { + if (nfds == ARRAY_SIZE(events) && --count != 0) { + /* Poll for more events but don't block this time. */ + timeout = 0; + continue; + } + return; + } + + if (timeout == 0) + return; + + if (timeout == -1) + continue; + +update_timeout: + assert(timeout > 0); + + real_timeout -= (loop->time - base); + if (real_timeout <= 0) + return; + + timeout = real_timeout; + } +} + diff --git a/src/unix/freebsd.c b/src/unix/freebsd.c index 191bc8b..658ff26 100644 --- a/src/unix/freebsd.c +++ b/src/unix/freebsd.c @@ -91,7 +91,7 @@ uint64_t uv_get_free_memory(void) { size_t size = sizeof(freecount); if (sysctlbyname("vm.stats.vm.v_free_count", &freecount, &size, NULL, 0)) - return 0; + return UV__ERR(errno); return (uint64_t) freecount * sysconf(_SC_PAGESIZE); @@ -105,7 +105,7 @@ uint64_t uv_get_total_memory(void) { size_t size = sizeof(info); if (sysctl(which, ARRAY_SIZE(which), &info, &size, NULL, 0)) - return 0; + return UV__ERR(errno); return (uint64_t) info; } @@ -116,11 +116,6 @@ uint64_t uv_get_constrained_memory(void) { } -uint64_t uv_get_available_memory(void) { - return uv_get_free_memory(); -} - - void uv_loadavg(double avg[3]) { struct loadavg info; size_t size = sizeof(info); @@ -269,6 +264,30 @@ int uv_cpu_info(uv_cpu_info_t** cpu_infos, int* count) { } +int uv__sendmmsg(int fd, struct uv__mmsghdr* mmsg, unsigned int vlen) { +#if __FreeBSD__ >= 11 && !defined(__DragonFly__) + return sendmmsg(fd, + (struct mmsghdr*) mmsg, + vlen, + 0 /* flags */); +#else + return errno = ENOSYS, -1; +#endif +} + + +int uv__recvmmsg(int fd, struct uv__mmsghdr* mmsg, unsigned int vlen) { +#if __FreeBSD__ >= 11 && !defined(__DragonFly__) + return recvmmsg(fd, + (struct mmsghdr*) mmsg, + vlen, + 0 /* flags */, + NULL /* timeout */); +#else + return errno = ENOSYS, -1; +#endif +} + ssize_t uv__fs_copy_file_range(int fd_in, off_t* off_in, diff --git a/src/unix/fs.c b/src/unix/fs.c index 484e40b..2a41fbf 100644 --- a/src/unix/fs.c +++ b/src/unix/fs.c @@ -41,15 +41,26 @@ #include #include #include +#include #include #include #include +#if defined(__DragonFly__) || \ + defined(__FreeBSD__) || \ + defined(__FreeBSD_kernel__) || \ + defined(__OpenBSD__) || \ + defined(__NetBSD__) +# define HAVE_PREADV 1 +#else +# define HAVE_PREADV 0 +#endif + #if defined(__linux__) -# include +# include "sys/utsname.h" #endif -#if defined(__sun) +#if defined(__linux__) || defined(__sun) # include # include #endif @@ -68,6 +79,7 @@ #if defined(__APPLE__) || \ defined(__DragonFly__) || \ defined(__FreeBSD__) || \ + defined(__FreeBSD_kernel__) || \ defined(__OpenBSD__) || \ defined(__NetBSD__) # include @@ -82,17 +94,6 @@ # include #endif -#if defined(__CYGWIN__) || \ - (defined(__HAIKU__) && B_HAIKU_VERSION < B_HAIKU_VERSION_1_PRE_BETA_5) || \ - (defined(__sun) && !defined(__illumos__)) || \ - (defined(__APPLE__) && !TARGET_OS_IPHONE && \ - MAC_OS_X_VERSION_MIN_REQUIRED < 110000) -#define preadv(fd, bufs, nbufs, off) \ - pread(fd, (bufs)->iov_base, (bufs)->iov_len, off) -#define pwritev(fd, bufs, nbufs, off) \ - pwrite(fd, (bufs)->iov_base, (bufs)->iov_len, off) -#endif - #if defined(_AIX) && _XOPEN_SOURCE <= 600 extern char *mkdtemp(char *template); /* See issue #740 on AIX < 7 */ #endif @@ -276,6 +277,7 @@ static ssize_t uv__fs_futime(uv_fs_t* req) { #elif defined(__APPLE__) \ || defined(__DragonFly__) \ || defined(__FreeBSD__) \ + || defined(__FreeBSD_kernel__) \ || defined(__NetBSD__) \ || defined(__OpenBSD__) \ || defined(__sun) @@ -330,7 +332,7 @@ static int uv__fs_mkstemp(uv_fs_t* req) { static uv_once_t once = UV_ONCE_INIT; int r; #ifdef O_CLOEXEC - static _Atomic int no_cloexec_support; + static int no_cloexec_support; #endif static const char pattern[] = "XXXXXX"; static const size_t pattern_size = sizeof(pattern) - 1; @@ -355,8 +357,7 @@ static int uv__fs_mkstemp(uv_fs_t* req) { uv_once(&once, uv__mkostemp_initonce); #ifdef O_CLOEXEC - if (atomic_load_explicit(&no_cloexec_support, memory_order_relaxed) == 0 && - uv__mkostemp != NULL) { + if (uv__load_relaxed(&no_cloexec_support) == 0 && uv__mkostemp != NULL) { r = uv__mkostemp(path, O_CLOEXEC); if (r >= 0) @@ -369,7 +370,7 @@ static int uv__fs_mkstemp(uv_fs_t* req) { /* We set the static variable so that next calls don't even try to use mkostemp. */ - atomic_store_explicit(&no_cloexec_support, 1, memory_order_relaxed); + uv__store_relaxed(&no_cloexec_support, 1); } #endif /* O_CLOEXEC */ @@ -427,66 +428,139 @@ static ssize_t uv__fs_open(uv_fs_t* req) { } +#if !HAVE_PREADV +static ssize_t uv__fs_preadv(uv_file fd, + uv_buf_t* bufs, + unsigned int nbufs, + off_t off) { + uv_buf_t* buf; + uv_buf_t* end; + ssize_t result; + ssize_t rc; + size_t pos; + + assert(nbufs > 0); + + result = 0; + pos = 0; + buf = bufs + 0; + end = bufs + nbufs; + + for (;;) { + do + rc = pread(fd, buf->base + pos, buf->len - pos, off + result); + while (rc == -1 && errno == EINTR); + + if (rc == 0) + break; + + if (rc == -1 && result == 0) + return UV__ERR(errno); + + if (rc == -1) + break; /* We read some data so return that, ignore the error. */ + + pos += rc; + result += rc; + + if (pos < buf->len) + continue; + + pos = 0; + buf += 1; + + if (buf == end) + break; + } + + return result; +} +#endif + + static ssize_t uv__fs_read(uv_fs_t* req) { - const struct iovec* bufs; +#if defined(__linux__) + static int no_preadv; +#endif unsigned int iovmax; - size_t nbufs; - ssize_t r; - off_t off; - int fd; - - fd = req->file; - off = req->off; - bufs = (const struct iovec*) req->bufs; - nbufs = req->nbufs; + ssize_t result; iovmax = uv__getiovmax(); - if (nbufs > iovmax) - nbufs = iovmax; - - r = 0; - if (off < 0) { - if (nbufs == 1) - r = read(fd, bufs->iov_base, bufs->iov_len); - else if (nbufs > 1) - r = readv(fd, bufs, nbufs); + if (req->nbufs > iovmax) + req->nbufs = iovmax; + + if (req->off < 0) { + if (req->nbufs == 1) + result = read(req->file, req->bufs[0].base, req->bufs[0].len); + else + result = readv(req->file, (struct iovec*) req->bufs, req->nbufs); } else { - if (nbufs == 1) - r = pread(fd, bufs->iov_base, bufs->iov_len, off); - else if (nbufs > 1) - r = preadv(fd, bufs, nbufs, off); + if (req->nbufs == 1) { + result = pread(req->file, req->bufs[0].base, req->bufs[0].len, req->off); + goto done; + } + +#if HAVE_PREADV + result = preadv(req->file, (struct iovec*) req->bufs, req->nbufs, req->off); +#else +# if defined(__linux__) + if (uv__load_relaxed(&no_preadv)) retry: +# endif + { + result = uv__fs_preadv(req->file, req->bufs, req->nbufs, req->off); + } +# if defined(__linux__) + else { + result = uv__preadv(req->file, + (struct iovec*)req->bufs, + req->nbufs, + req->off); + if (result == -1 && errno == ENOSYS) { + uv__store_relaxed(&no_preadv, 1); + goto retry; + } + } +# endif +#endif } +done: + /* Early cleanup of bufs allocation, since we're done with it. */ + if (req->bufs != req->bufsml) + uv__free(req->bufs); + + req->bufs = NULL; + req->nbufs = 0; + #ifdef __PASE__ /* PASE returns EOPNOTSUPP when reading a directory, convert to EISDIR */ - if (r == -1 && errno == EOPNOTSUPP) { + if (result == -1 && errno == EOPNOTSUPP) { struct stat buf; ssize_t rc; - rc = uv__fstat(fd, &buf); + rc = fstat(req->file, &buf); if (rc == 0 && S_ISDIR(buf.st_mode)) { errno = EISDIR; } } #endif - /* We don't own the buffer list in the synchronous case. */ - if (req->cb != NULL) - if (req->bufs != req->bufsml) - uv__free(req->bufs); + return result; +} - req->bufs = NULL; - req->nbufs = 0; - return r; -} +#if defined(__APPLE__) && !defined(MAC_OS_X_VERSION_10_8) +#define UV_CONST_DIRENT uv__dirent_t +#else +#define UV_CONST_DIRENT const uv__dirent_t +#endif -static int uv__fs_scandir_filter(const uv__dirent_t* dent) { +static int uv__fs_scandir_filter(UV_CONST_DIRENT* dent) { return strcmp(dent->d_name, ".") != 0 && strcmp(dent->d_name, "..") != 0; } -static int uv__fs_scandir_sort(const uv__dirent_t** a, const uv__dirent_t** b) { +static int uv__fs_scandir_sort(UV_CONST_DIRENT** a, UV_CONST_DIRENT** b) { return strcmp((*a)->d_name, (*b)->d_name); } @@ -662,7 +736,7 @@ static ssize_t uv__fs_readlink(uv_fs_t* req) { /* We may not have a real PATH_MAX. Read size of link. */ struct stat st; int ret; - ret = uv__lstat(req->path, &st); + ret = lstat(req->path, &st); if (ret != 0) return -1; if (!S_ISLNK(st.st_mode)) { @@ -854,6 +928,31 @@ out: #ifdef __linux__ +static unsigned uv__kernel_version(void) { + static unsigned cached_version; + struct utsname u; + unsigned version; + unsigned major; + unsigned minor; + unsigned patch; + + version = uv__load_relaxed(&cached_version); + if (version != 0) + return version; + + if (-1 == uname(&u)) + return 0; + + if (3 != sscanf(u.release, "%u.%u.%u", &major, &minor, &patch)) + return 0; + + version = major * 65536 + minor * 256 + patch; + uv__store_relaxed(&cached_version, version); + + return version; +} + + /* Pre-4.20 kernels have a bug where CephFS uses the RADOS copy-from command * in copy_file_range() when it shouldn't. There is no workaround except to * fall back to a regular copy. @@ -890,10 +989,10 @@ static int uv__is_cifs_or_smb(int fd) { static ssize_t uv__fs_try_copy_file_range(int in_fd, off_t* off, int out_fd, size_t len) { - static _Atomic int no_copy_file_range_support; + static int no_copy_file_range_support; ssize_t r; - if (atomic_load_explicit(&no_copy_file_range_support, memory_order_relaxed)) { + if (uv__load_relaxed(&no_copy_file_range_support)) { errno = ENOSYS; return -1; } @@ -912,7 +1011,7 @@ static ssize_t uv__fs_try_copy_file_range(int in_fd, off_t* off, errno = ENOSYS; /* Use fallback. */ break; case ENOSYS: - atomic_store_explicit(&no_copy_file_range_support, 1, memory_order_relaxed); + uv__store_relaxed(&no_copy_file_range_support, 1); break; case EPERM: /* It's been reported that CIFS spuriously fails. @@ -983,7 +1082,10 @@ static ssize_t uv__fs_sendfile(uv_fs_t* req) { return -1; } -#elif defined(__APPLE__) || defined(__DragonFly__) || defined(__FreeBSD__) +#elif defined(__APPLE__) || \ + defined(__DragonFly__) || \ + defined(__FreeBSD__) || \ + defined(__FreeBSD_kernel__) { off_t len; ssize_t r; @@ -1007,6 +1109,15 @@ static ssize_t uv__fs_sendfile(uv_fs_t* req) { #endif len = 0; r = sendfile(in_fd, out_fd, req->off, req->bufsml[0].len, NULL, &len, 0); +#elif defined(__FreeBSD_kernel__) + len = 0; + r = bsd_sendfile(in_fd, + out_fd, + req->off, + req->bufsml[0].len, + NULL, + &len, + 0); #else /* The darwin sendfile takes len as an input for the length to send, * so make sure to initialize it with the caller's value. */ @@ -1058,6 +1169,7 @@ static ssize_t uv__fs_utime(uv_fs_t* req) { #elif defined(__APPLE__) \ || defined(__DragonFly__) \ || defined(__FreeBSD__) \ + || defined(__FreeBSD_kernel__) \ || defined(__NetBSD__) \ || defined(__OpenBSD__) struct timeval tv[2]; @@ -1099,6 +1211,7 @@ static ssize_t uv__fs_lutime(uv_fs_t* req) { #elif defined(__APPLE__) || \ defined(__DragonFly__) || \ defined(__FreeBSD__) || \ + defined(__FreeBSD_kernel__) || \ defined(__NetBSD__) struct timeval tv[2]; tv[0] = uv__fs_to_timeval(req->atime); @@ -1112,34 +1225,65 @@ static ssize_t uv__fs_lutime(uv_fs_t* req) { static ssize_t uv__fs_write(uv_fs_t* req) { - const struct iovec* bufs; - size_t nbufs; +#if defined(__linux__) + static int no_pwritev; +#endif ssize_t r; - off_t off; - int fd; - fd = req->file; - off = req->off; - bufs = (const struct iovec*) req->bufs; - nbufs = req->nbufs; + /* Serialize writes on OS X, concurrent write() and pwrite() calls result in + * data loss. We can't use a per-file descriptor lock, the descriptor may be + * a dup(). + */ +#if defined(__APPLE__) + static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER; - r = 0; - if (off < 0) { - if (nbufs == 1) - r = write(fd, bufs->iov_base, bufs->iov_len); - else if (nbufs > 1) - r = writev(fd, bufs, nbufs); + if (pthread_mutex_lock(&lock)) + abort(); +#endif + + if (req->off < 0) { + if (req->nbufs == 1) + r = write(req->file, req->bufs[0].base, req->bufs[0].len); + else + r = writev(req->file, (struct iovec*) req->bufs, req->nbufs); } else { - if (nbufs == 1) - r = pwrite(fd, bufs->iov_base, bufs->iov_len, off); - else if (nbufs > 1) - r = pwritev(fd, bufs, nbufs, off); + if (req->nbufs == 1) { + r = pwrite(req->file, req->bufs[0].base, req->bufs[0].len, req->off); + goto done; + } +#if HAVE_PREADV + r = pwritev(req->file, (struct iovec*) req->bufs, req->nbufs, req->off); +#else +# if defined(__linux__) + if (no_pwritev) retry: +# endif + { + r = pwrite(req->file, req->bufs[0].base, req->bufs[0].len, req->off); + } +# if defined(__linux__) + else { + r = uv__pwritev(req->file, + (struct iovec*) req->bufs, + req->nbufs, + req->off); + if (r == -1 && errno == ENOSYS) { + no_pwritev = 1; + goto retry; + } + } +# endif +#endif } +done: +#if defined(__APPLE__) + if (pthread_mutex_unlock(&lock)) + abort(); +#endif + return r; } - static ssize_t uv__fs_copyfile(uv_fs_t* req) { uv_fs_t fs_req; uv_file srcfd; @@ -1165,7 +1309,7 @@ static ssize_t uv__fs_copyfile(uv_fs_t* req) { return srcfd; /* Get the source file's mode. */ - if (uv__fstat(srcfd, &src_statsbuf)) { + if (fstat(srcfd, &src_statsbuf)) { err = UV__ERR(errno); goto out; } @@ -1193,7 +1337,7 @@ static ssize_t uv__fs_copyfile(uv_fs_t* req) { destination are not the same file. If they are the same, bail out early. */ if ((req->flags & UV_FS_COPYFILE_EXCL) == 0) { /* Get the destination file's mode. */ - if (uv__fstat(dstfd, &dst_statsbuf)) { + if (fstat(dstfd, &dst_statsbuf)) { err = UV__ERR(errno); goto out; } @@ -1207,19 +1351,7 @@ static ssize_t uv__fs_copyfile(uv_fs_t* req) { /* Truncate the file in case the destination already existed. */ if (ftruncate(dstfd, 0) != 0) { err = UV__ERR(errno); - - /* ftruncate() on ceph-fuse fails with EACCES when the file is created - * with read only permissions. Since ftruncate() on a newly created - * file is a meaningless operation anyway, detect that condition - * and squelch the error. - */ - if (err != UV_EACCES) - goto out; - - if (dst_statsbuf.st_size > 0) - goto out; - - err = 0; + goto out; } } @@ -1403,14 +1535,14 @@ static int uv__fs_statx(int fd, uv_stat_t* buf) { STATIC_ASSERT(UV_ENOSYS != -1); #ifdef __linux__ - static _Atomic int no_statx; + static int no_statx; struct uv__statx statxbuf; int dirfd; int flags; int mode; int rc; - if (atomic_load_explicit(&no_statx, memory_order_relaxed)) + if (uv__load_relaxed(&no_statx)) return UV_ENOSYS; dirfd = AT_FDCWD; @@ -1444,11 +1576,30 @@ static int uv__fs_statx(int fd, * implemented, rc might return 1 with 0 set as the error code in which * case we return ENOSYS. */ - atomic_store_explicit(&no_statx, 1, memory_order_relaxed); + uv__store_relaxed(&no_statx, 1); return UV_ENOSYS; } - uv__statx_to_stat(&statxbuf, buf); + buf->st_dev = makedev(statxbuf.stx_dev_major, statxbuf.stx_dev_minor); + buf->st_mode = statxbuf.stx_mode; + buf->st_nlink = statxbuf.stx_nlink; + buf->st_uid = statxbuf.stx_uid; + buf->st_gid = statxbuf.stx_gid; + buf->st_rdev = makedev(statxbuf.stx_rdev_major, statxbuf.stx_rdev_minor); + buf->st_ino = statxbuf.stx_ino; + buf->st_size = statxbuf.stx_size; + buf->st_blksize = statxbuf.stx_blksize; + buf->st_blocks = statxbuf.stx_blocks; + buf->st_atim.tv_sec = statxbuf.stx_atime.tv_sec; + buf->st_atim.tv_nsec = statxbuf.stx_atime.tv_nsec; + buf->st_mtim.tv_sec = statxbuf.stx_mtime.tv_sec; + buf->st_mtim.tv_nsec = statxbuf.stx_mtime.tv_nsec; + buf->st_ctim.tv_sec = statxbuf.stx_ctime.tv_sec; + buf->st_ctim.tv_nsec = statxbuf.stx_ctime.tv_nsec; + buf->st_birthtim.tv_sec = statxbuf.stx_btime.tv_sec; + buf->st_birthtim.tv_nsec = statxbuf.stx_btime.tv_nsec; + buf->st_flags = 0; + buf->st_gen = 0; return 0; #else @@ -1465,7 +1616,7 @@ static int uv__fs_stat(const char *path, uv_stat_t *buf) { if (ret != UV_ENOSYS) return ret; - ret = uv__stat(path, &pbuf); + ret = stat(path, &pbuf); if (ret == 0) uv__to_stat(&pbuf, buf); @@ -1481,7 +1632,7 @@ static int uv__fs_lstat(const char *path, uv_stat_t *buf) { if (ret != UV_ENOSYS) return ret; - ret = uv__lstat(path, &pbuf); + ret = lstat(path, &pbuf); if (ret == 0) uv__to_stat(&pbuf, buf); @@ -1497,7 +1648,7 @@ static int uv__fs_fstat(int fd, uv_stat_t *buf) { if (ret != UV_ENOSYS) return ret; - ret = uv__fstat(fd, &pbuf); + ret = fstat(fd, &pbuf); if (ret == 0) uv__to_stat(&pbuf, buf); @@ -1651,19 +1802,6 @@ static void uv__fs_done(struct uv__work* w, int status) { } -void uv__fs_post(uv_loop_t* loop, uv_fs_t* req) { - uv__req_register(loop, req); - uv__work_submit(loop, -#ifdef USE_FFRT - NULL, -#endif - &req->work_req, - UV__WORK_FAST_IO, - uv__fs_work, - uv__fs_done); -} - - int uv_fs_access(uv_loop_t* loop, uv_fs_t* req, const char* path, @@ -1705,9 +1843,6 @@ int uv_fs_chown(uv_loop_t* loop, int uv_fs_close(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb) { INIT(CLOSE); req->file = file; - if (cb != NULL) - if (uv__iou_fs_close(loop, req)) - return 0; POST; } @@ -1755,9 +1890,6 @@ int uv_fs_lchown(uv_loop_t* loop, int uv_fs_fdatasync(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb) { INIT(FDATASYNC); req->file = file; - if (cb != NULL) - if (uv__iou_fs_fsync_or_fdatasync(loop, req, /* IORING_FSYNC_DATASYNC */ 1)) - return 0; POST; } @@ -1765,9 +1897,6 @@ int uv_fs_fdatasync(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb) { int uv_fs_fstat(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb) { INIT(FSTAT); req->file = file; - if (cb != NULL) - if (uv__iou_fs_statx(loop, req, /* is_fstat */ 1, /* is_lstat */ 0)) - return 0; POST; } @@ -1775,9 +1904,6 @@ int uv_fs_fstat(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb) { int uv_fs_fsync(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb) { INIT(FSYNC); req->file = file; - if (cb != NULL) - if (uv__iou_fs_fsync_or_fdatasync(loop, req, /* no flags */ 0)) - return 0; POST; } @@ -1824,9 +1950,6 @@ int uv_fs_lutime(uv_loop_t* loop, int uv_fs_lstat(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) { INIT(LSTAT); PATH; - if (cb != NULL) - if (uv__iou_fs_statx(loop, req, /* is_fstat */ 0, /* is_lstat */ 1)) - return 0; POST; } @@ -1838,9 +1961,6 @@ int uv_fs_link(uv_loop_t* loop, uv_fs_cb cb) { INIT(LINK); PATH2; - if (cb != NULL) - if (uv__iou_fs_link(loop, req)) - return 0; POST; } @@ -1853,9 +1973,6 @@ int uv_fs_mkdir(uv_loop_t* loop, INIT(MKDIR); PATH; req->mode = mode; - if (cb != NULL) - if (uv__iou_fs_mkdir(loop, req)) - return 0; POST; } @@ -1894,9 +2011,6 @@ int uv_fs_open(uv_loop_t* loop, PATH; req->flags = flags; req->mode = mode; - if (cb != NULL) - if (uv__iou_fs_open(loop, req)) - return 0; POST; } @@ -1912,14 +2026,9 @@ int uv_fs_read(uv_loop_t* loop, uv_fs_t* req, if (bufs == NULL || nbufs == 0) return UV_EINVAL; - req->off = off; req->file = file; - req->bufs = (uv_buf_t*) bufs; /* Safe, doesn't mutate |bufs| */ - req->nbufs = nbufs; - - if (cb == NULL) - goto post; + req->nbufs = nbufs; req->bufs = req->bufsml; if (nbufs > ARRAY_SIZE(req->bufsml)) req->bufs = uv__malloc(nbufs * sizeof(*bufs)); @@ -1929,10 +2038,7 @@ int uv_fs_read(uv_loop_t* loop, uv_fs_t* req, memcpy(req->bufs, bufs, nbufs * sizeof(*bufs)); - if (uv__iou_fs_read_or_write(loop, req, /* is_read */ 1)) - return 0; - -post: + req->off = off; POST; } @@ -2010,9 +2116,6 @@ int uv_fs_rename(uv_loop_t* loop, uv_fs_cb cb) { INIT(RENAME); PATH2; - if (cb != NULL) - if (uv__iou_fs_rename(loop, req)) - return 0; POST; } @@ -2043,9 +2146,6 @@ int uv_fs_sendfile(uv_loop_t* loop, int uv_fs_stat(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) { INIT(STAT); PATH; - if (cb != NULL) - if (uv__iou_fs_statx(loop, req, /* is_fstat */ 0, /* is_lstat */ 0)) - return 0; POST; } @@ -2059,9 +2159,6 @@ int uv_fs_symlink(uv_loop_t* loop, INIT(SYMLINK); PATH2; req->flags = flags; - if (cb != NULL) - if (uv__iou_fs_symlink(loop, req)) - return 0; POST; } @@ -2069,9 +2166,6 @@ int uv_fs_symlink(uv_loop_t* loop, int uv_fs_unlink(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) { INIT(UNLINK); PATH; - if (cb != NULL) - if (uv__iou_fs_unlink(loop, req)) - return 0; POST; } @@ -2115,11 +2209,6 @@ int uv_fs_write(uv_loop_t* loop, memcpy(req->bufs, bufs, nbufs * sizeof(*bufs)); req->off = off; - - if (cb != NULL) - if (uv__iou_fs_read_or_write(loop, req, /* is_read */ 0)) - return 0; - POST; } @@ -2128,7 +2217,7 @@ void uv_fs_req_cleanup(uv_fs_t* req) { if (req == NULL) return; - /* Only necessary for asynchronous requests, i.e., requests with a callback. + /* Only necessary for asychronous requests, i.e., requests with a callback. * Synchronous ones don't copy their arguments and have req->path and * req->new_path pointing to user-owned memory. UV_FS_MKDTEMP and * UV_FS_MKSTEMP are the exception to the rule, they always allocate memory. diff --git a/src/unix/fsevents.c b/src/unix/fsevents.c index df703f3..bf4f1f6 100644 --- a/src/unix/fsevents.c +++ b/src/unix/fsevents.c @@ -80,13 +80,13 @@ enum uv__cf_loop_signal_type_e { typedef enum uv__cf_loop_signal_type_e uv__cf_loop_signal_type_t; struct uv__cf_loop_signal_s { - struct uv__queue member; + QUEUE member; uv_fs_event_t* handle; uv__cf_loop_signal_type_t type; }; struct uv__fsevents_event_s { - struct uv__queue member; + QUEUE member; int events; char path[1]; }; @@ -98,7 +98,7 @@ struct uv__cf_loop_state_s { FSEventStreamRef fsevent_stream; uv_sem_t fsevent_sem; uv_mutex_t fsevent_mutex; - struct uv__queue fsevent_handles; + void* fsevent_handles[2]; unsigned int fsevent_handle_count; }; @@ -132,6 +132,7 @@ static void (*pCFRunLoopWakeUp)(CFRunLoopRef); static CFStringRef (*pCFStringCreateWithFileSystemRepresentation)( CFAllocatorRef, const char*); +static CFStringEncoding (*pCFStringGetSystemEncoding)(void); static CFStringRef (*pkCFRunLoopDefaultMode); static FSEventStreamRef (*pFSEventStreamCreate)(CFAllocatorRef, FSEventStreamCallback, @@ -140,6 +141,7 @@ static FSEventStreamRef (*pFSEventStreamCreate)(CFAllocatorRef, FSEventStreamEventId, CFTimeInterval, FSEventStreamCreateFlags); +static void (*pFSEventStreamFlushSync)(FSEventStreamRef); static void (*pFSEventStreamInvalidate)(FSEventStreamRef); static void (*pFSEventStreamRelease)(FSEventStreamRef); static void (*pFSEventStreamScheduleWithRunLoop)(FSEventStreamRef, @@ -150,22 +152,22 @@ static void (*pFSEventStreamStop)(FSEventStreamRef); #define UV__FSEVENTS_PROCESS(handle, block) \ do { \ - struct uv__queue events; \ - struct uv__queue* q; \ + QUEUE events; \ + QUEUE* q; \ uv__fsevents_event_t* event; \ int err; \ uv_mutex_lock(&(handle)->cf_mutex); \ /* Split-off all events and empty original queue */ \ - uv__queue_move(&(handle)->cf_events, &events); \ + QUEUE_MOVE(&(handle)->cf_events, &events); \ /* Get error (if any) and zero original one */ \ err = (handle)->cf_error; \ (handle)->cf_error = 0; \ uv_mutex_unlock(&(handle)->cf_mutex); \ /* Loop through events, deallocating each after processing */ \ - while (!uv__queue_empty(&events)) { \ - q = uv__queue_head(&events); \ - event = uv__queue_data(q, uv__fsevents_event_t, member); \ - uv__queue_remove(q); \ + while (!QUEUE_EMPTY(&events)) { \ + q = QUEUE_HEAD(&events); \ + event = QUEUE_DATA(q, uv__fsevents_event_t, member); \ + QUEUE_REMOVE(q); \ /* NOTE: Checking uv__is_active() is required here, because handle \ * callback may close handle and invoking it after it will lead to \ * incorrect behaviour */ \ @@ -193,14 +195,14 @@ static void uv__fsevents_cb(uv_async_t* cb) { /* Runs in CF thread, pushed event into handle's event list */ static void uv__fsevents_push_event(uv_fs_event_t* handle, - struct uv__queue* events, + QUEUE* events, int err) { assert(events != NULL || err != 0); uv_mutex_lock(&handle->cf_mutex); /* Concatenate two queues */ if (events != NULL) - uv__queue_add(&handle->cf_events, events); + QUEUE_ADD(&handle->cf_events, events); /* Propagate error */ if (err != 0) @@ -224,12 +226,12 @@ static void uv__fsevents_event_cb(const FSEventStreamRef streamRef, char* path; char* pos; uv_fs_event_t* handle; - struct uv__queue* q; + QUEUE* q; uv_loop_t* loop; uv__cf_loop_state_t* state; uv__fsevents_event_t* event; FSEventStreamEventFlags flags; - struct uv__queue head; + QUEUE head; loop = info; state = loop->cf_state; @@ -238,9 +240,9 @@ static void uv__fsevents_event_cb(const FSEventStreamRef streamRef, /* For each handle */ uv_mutex_lock(&state->fsevent_mutex); - uv__queue_foreach(q, &state->fsevent_handles) { - handle = uv__queue_data(q, uv_fs_event_t, cf_member); - uv__queue_init(&head); + QUEUE_FOREACH(q, &state->fsevent_handles) { + handle = QUEUE_DATA(q, uv_fs_event_t, cf_member); + QUEUE_INIT(&head); /* Process and filter out events */ for (i = 0; i < numEvents; i++) { @@ -318,10 +320,10 @@ static void uv__fsevents_event_cb(const FSEventStreamRef streamRef, event->events = UV_CHANGE; } - uv__queue_insert_tail(&head, &event->member); + QUEUE_INSERT_TAIL(&head, &event->member); } - if (!uv__queue_empty(&head)) + if (!QUEUE_EMPTY(&head)) uv__fsevents_push_event(handle, &head, 0); } uv_mutex_unlock(&state->fsevent_mutex); @@ -329,9 +331,8 @@ static void uv__fsevents_event_cb(const FSEventStreamRef streamRef, /* Runs in CF thread */ -static int uv__fsevents_create_stream(uv__cf_loop_state_t* state, - uv_loop_t* loop, - CFArrayRef paths) { +static int uv__fsevents_create_stream(uv_loop_t* loop, CFArrayRef paths) { + uv__cf_loop_state_t* state; FSEventStreamContext ctx; FSEventStreamRef ref; CFAbsoluteTime latency; @@ -372,7 +373,10 @@ static int uv__fsevents_create_stream(uv__cf_loop_state_t* state, flags); assert(ref != NULL); - pFSEventStreamScheduleWithRunLoop(ref, state->loop, *pkCFRunLoopDefaultMode); + state = loop->cf_state; + pFSEventStreamScheduleWithRunLoop(ref, + state->loop, + *pkCFRunLoopDefaultMode); if (!pFSEventStreamStart(ref)) { pFSEventStreamInvalidate(ref); pFSEventStreamRelease(ref); @@ -385,7 +389,11 @@ static int uv__fsevents_create_stream(uv__cf_loop_state_t* state, /* Runs in CF thread */ -static void uv__fsevents_destroy_stream(uv__cf_loop_state_t* state) { +static void uv__fsevents_destroy_stream(uv_loop_t* loop) { + uv__cf_loop_state_t* state; + + state = loop->cf_state; + if (state->fsevent_stream == NULL) return; @@ -400,10 +408,10 @@ static void uv__fsevents_destroy_stream(uv__cf_loop_state_t* state) { /* Runs in CF thread, when there're new fsevent handles to add to stream */ -static void uv__fsevents_reschedule(uv__cf_loop_state_t* state, - uv_loop_t* loop, +static void uv__fsevents_reschedule(uv_fs_event_t* handle, uv__cf_loop_signal_type_t type) { - struct uv__queue* q; + uv__cf_loop_state_t* state; + QUEUE* q; uv_fs_event_t* curr; CFArrayRef cf_paths; CFStringRef* paths; @@ -411,6 +419,7 @@ static void uv__fsevents_reschedule(uv__cf_loop_state_t* state, int err; unsigned int path_count; + state = handle->loop->cf_state; paths = NULL; cf_paths = NULL; err = 0; @@ -429,7 +438,7 @@ static void uv__fsevents_reschedule(uv__cf_loop_state_t* state, uv_mutex_unlock(&state->fsevent_mutex); /* Destroy previous FSEventStream */ - uv__fsevents_destroy_stream(state); + uv__fsevents_destroy_stream(handle->loop); /* Any failure below will be a memory failure */ err = UV_ENOMEM; @@ -446,9 +455,9 @@ static void uv__fsevents_reschedule(uv__cf_loop_state_t* state, q = &state->fsevent_handles; for (; i < path_count; i++) { - q = uv__queue_next(q); + q = QUEUE_NEXT(q); assert(q != &state->fsevent_handles); - curr = uv__queue_data(q, uv_fs_event_t, cf_member); + curr = QUEUE_DATA(q, uv_fs_event_t, cf_member); assert(curr->realpath != NULL); paths[i] = @@ -469,7 +478,7 @@ static void uv__fsevents_reschedule(uv__cf_loop_state_t* state, err = UV_ENOMEM; goto final; } - err = uv__fsevents_create_stream(state, loop, cf_paths); + err = uv__fsevents_create_stream(handle->loop, cf_paths); } final: @@ -486,8 +495,8 @@ final: /* Broadcast error to all handles */ uv_mutex_lock(&state->fsevent_mutex); - uv__queue_foreach(q, &state->fsevent_handles) { - curr = uv__queue_data(q, uv_fs_event_t, cf_member); + QUEUE_FOREACH(q, &state->fsevent_handles) { + curr = QUEUE_DATA(q, uv_fs_event_t, cf_member); uv__fsevents_push_event(curr, NULL, err); } uv_mutex_unlock(&state->fsevent_mutex); @@ -554,8 +563,10 @@ static int uv__fsevents_global_init(void) { V(core_foundation_handle, CFRunLoopStop); V(core_foundation_handle, CFRunLoopWakeUp); V(core_foundation_handle, CFStringCreateWithFileSystemRepresentation); + V(core_foundation_handle, CFStringGetSystemEncoding); V(core_foundation_handle, kCFRunLoopDefaultMode); V(core_services_handle, FSEventStreamCreate); + V(core_services_handle, FSEventStreamFlushSync); V(core_services_handle, FSEventStreamInvalidate); V(core_services_handle, FSEventStreamRelease); V(core_services_handle, FSEventStreamScheduleWithRunLoop); @@ -606,7 +617,7 @@ static int uv__fsevents_loop_init(uv_loop_t* loop) { if (err) goto fail_sem_init; - uv__queue_init(&loop->cf_signals); + QUEUE_INIT(&loop->cf_signals); err = uv_sem_init(&state->fsevent_sem, 0); if (err) @@ -616,7 +627,7 @@ static int uv__fsevents_loop_init(uv_loop_t* loop) { if (err) goto fail_fsevent_mutex_init; - uv__queue_init(&state->fsevent_handles); + QUEUE_INIT(&state->fsevent_handles); state->fsevent_need_reschedule = 0; state->fsevent_handle_count = 0; @@ -675,7 +686,7 @@ fail_mutex_init: void uv__fsevents_loop_delete(uv_loop_t* loop) { uv__cf_loop_signal_t* s; uv__cf_loop_state_t* state; - struct uv__queue* q; + QUEUE* q; if (loop->cf_state == NULL) return; @@ -688,10 +699,10 @@ void uv__fsevents_loop_delete(uv_loop_t* loop) { uv_mutex_destroy(&loop->cf_mutex); /* Free any remaining data */ - while (!uv__queue_empty(&loop->cf_signals)) { - q = uv__queue_head(&loop->cf_signals); - s = uv__queue_data(q, uv__cf_loop_signal_t, member); - uv__queue_remove(q); + while (!QUEUE_EMPTY(&loop->cf_signals)) { + q = QUEUE_HEAD(&loop->cf_signals); + s = QUEUE_DATA(q, uv__cf_loop_signal_t, member); + QUEUE_REMOVE(q); uv__free(s); } @@ -735,28 +746,28 @@ static void* uv__cf_loop_runner(void* arg) { static void uv__cf_loop_cb(void* arg) { uv_loop_t* loop; uv__cf_loop_state_t* state; - struct uv__queue* item; - struct uv__queue split_head; + QUEUE* item; + QUEUE split_head; uv__cf_loop_signal_t* s; loop = arg; state = loop->cf_state; uv_mutex_lock(&loop->cf_mutex); - uv__queue_move(&loop->cf_signals, &split_head); + QUEUE_MOVE(&loop->cf_signals, &split_head); uv_mutex_unlock(&loop->cf_mutex); - while (!uv__queue_empty(&split_head)) { - item = uv__queue_head(&split_head); - uv__queue_remove(item); + while (!QUEUE_EMPTY(&split_head)) { + item = QUEUE_HEAD(&split_head); + QUEUE_REMOVE(item); - s = uv__queue_data(item, uv__cf_loop_signal_t, member); + s = QUEUE_DATA(item, uv__cf_loop_signal_t, member); /* This was a termination signal */ if (s->handle == NULL) pCFRunLoopStop(state->loop); else - uv__fsevents_reschedule(state, loop, s->type); + uv__fsevents_reschedule(s->handle, s->type); uv__free(s); } @@ -778,7 +789,7 @@ int uv__cf_loop_signal(uv_loop_t* loop, item->type = type; uv_mutex_lock(&loop->cf_mutex); - uv__queue_insert_tail(&loop->cf_signals, &item->member); + QUEUE_INSERT_TAIL(&loop->cf_signals, &item->member); state = loop->cf_state; assert(state != NULL); @@ -807,7 +818,7 @@ int uv__fsevents_init(uv_fs_event_t* handle) { handle->realpath_len = strlen(handle->realpath); /* Initialize event queue */ - uv__queue_init(&handle->cf_events); + QUEUE_INIT(&handle->cf_events); handle->cf_error = 0; /* @@ -832,7 +843,7 @@ int uv__fsevents_init(uv_fs_event_t* handle) { /* Insert handle into the list */ state = handle->loop->cf_state; uv_mutex_lock(&state->fsevent_mutex); - uv__queue_insert_tail(&state->fsevent_handles, &handle->cf_member); + QUEUE_INSERT_TAIL(&state->fsevent_handles, &handle->cf_member); state->fsevent_handle_count++; state->fsevent_need_reschedule = 1; uv_mutex_unlock(&state->fsevent_mutex); @@ -872,7 +883,7 @@ int uv__fsevents_close(uv_fs_event_t* handle) { /* Remove handle from the list */ state = handle->loop->cf_state; uv_mutex_lock(&state->fsevent_mutex); - uv__queue_remove(&handle->cf_member); + QUEUE_REMOVE(&handle->cf_member); state->fsevent_handle_count--; state->fsevent_need_reschedule = 1; uv_mutex_unlock(&state->fsevent_mutex); diff --git a/src/unix/haiku.c b/src/unix/haiku.c index 31284b6..cf17d83 100644 --- a/src/unix/haiku.c +++ b/src/unix/haiku.c @@ -84,11 +84,6 @@ uint64_t uv_get_constrained_memory(void) { } -uint64_t uv_get_available_memory(void) { - return uv_get_free_memory(); -} - - int uv_resident_set_memory(size_t* rss) { area_info area; ssize_t cookie; diff --git a/src/unix/hurd.c b/src/unix/hurd.c index 63c8781..d19ea63 100644 --- a/src/unix/hurd.c +++ b/src/unix/hurd.c @@ -165,8 +165,3 @@ int uv_cpu_info(uv_cpu_info_t** cpu_infos, int* count) { uint64_t uv_get_constrained_memory(void) { return 0; /* Memory constraints are unknown. */ } - - -uint64_t uv_get_available_memory(void) { - return uv_get_free_memory(); -} diff --git a/src/unix/ibmi.c b/src/unix/ibmi.c index 837bba6..8c6ae63 100644 --- a/src/unix/ibmi.c +++ b/src/unix/ibmi.c @@ -249,11 +249,6 @@ uint64_t uv_get_constrained_memory(void) { } -uint64_t uv_get_available_memory(void) { - return uv_get_free_memory(); -} - - void uv_loadavg(double avg[3]) { SSTS0200 rcvr; diff --git a/src/unix/internal.h b/src/unix/internal.h index 80e596a..8554d9f 100644 --- a/src/unix/internal.h +++ b/src/unix/internal.h @@ -26,34 +26,23 @@ #include #include /* _POSIX_PATH_MAX, PATH_MAX */ -#include #include /* abort */ #include /* strrchr */ #include /* O_CLOEXEC and O_NONBLOCK, if supported. */ #include #include #include -#include -#include -#define UV_LOOP_MAGIC 0x100B100BU -#define uv__msan_unpoison(p, n) \ - do { \ - (void) (p); \ - (void) (n); \ - } while (0) -#if defined(__has_feature) -# if __has_feature(memory_sanitizer) -# include -# undef uv__msan_unpoison -# define uv__msan_unpoison __msan_unpoison -# endif -#endif +#define UV_LOOP_MAGIC 0x100B100BU #if defined(__STRICT_ANSI__) # define inline __inline #endif +#if defined(__linux__) +# include "linux-syscalls.h" +#endif /* __linux__ */ + #if defined(__MVS__) # include "os390-syscalls.h" #endif /* __MVS__ */ @@ -92,11 +81,13 @@ # define UV__PATH_MAX 8192 #endif -union uv__sockaddr { - struct sockaddr_in6 in6; - struct sockaddr_in in; - struct sockaddr addr; -}; +#if defined(__ANDROID__) +int uv__pthread_sigmask(int how, const sigset_t* set, sigset_t* oset); +# ifdef pthread_sigmask +# undef pthread_sigmask +# endif +# define pthread_sigmask(how, set, oldset) uv__pthread_sigmask(how, set, oldset) +#endif #define ACCESS_ONCE(type, var) \ (*(volatile type*) &(var)) @@ -177,42 +168,12 @@ struct uv__stream_queued_fds_s { int fds[1]; }; -#ifdef __linux__ -struct uv__statx_timestamp { - int64_t tv_sec; - uint32_t tv_nsec; - int32_t unused0; -}; - -struct uv__statx { - uint32_t stx_mask; - uint32_t stx_blksize; - uint64_t stx_attributes; - uint32_t stx_nlink; - uint32_t stx_uid; - uint32_t stx_gid; - uint16_t stx_mode; - uint16_t unused0; - uint64_t stx_ino; - uint64_t stx_size; - uint64_t stx_blocks; - uint64_t stx_attributes_mask; - struct uv__statx_timestamp stx_atime; - struct uv__statx_timestamp stx_btime; - struct uv__statx_timestamp stx_ctime; - struct uv__statx_timestamp stx_mtime; - uint32_t stx_rdev_major; - uint32_t stx_rdev_minor; - uint32_t stx_dev_major; - uint32_t stx_dev_minor; - uint64_t unused1[14]; -}; -#endif /* __linux__ */ #if defined(_AIX) || \ defined(__APPLE__) || \ defined(__DragonFly__) || \ defined(__FreeBSD__) || \ + defined(__FreeBSD_kernel__) || \ defined(__linux__) || \ defined(__OpenBSD__) || \ defined(__NetBSD__) @@ -299,10 +260,10 @@ int uv__signal_loop_fork(uv_loop_t* loop); /* platform specific */ uint64_t uv__hrtime(uv_clocktype_t type); int uv__kqueue_init(uv_loop_t* loop); +int uv__epoll_init(uv_loop_t* loop); int uv__platform_loop_init(uv_loop_t* loop); void uv__platform_loop_delete(uv_loop_t* loop); void uv__platform_invalidate_fd(uv_loop_t* loop, int fd); -int uv__process_init(uv_loop_t* loop); /* various */ void uv__async_close(uv_async_t* handle); @@ -319,6 +280,7 @@ size_t uv__thread_stack_size(void); void uv__udp_close(uv_udp_t* handle); void uv__udp_finish_close(uv_udp_t* handle); FILE* uv__open_file(const char* path); +int uv__getpwuid_r(uv_passwd_t* pwd); int uv__search_path(const char* prog, char* buf, size_t* buflen); void uv__wait_children(uv_loop_t* loop); @@ -329,38 +291,6 @@ int uv__random_getentropy(void* buf, size_t buflen); int uv__random_readpath(const char* path, void* buf, size_t buflen); int uv__random_sysctl(void* buf, size_t buflen); -/* io_uring */ -#ifdef __linux__ -int uv__iou_fs_close(uv_loop_t* loop, uv_fs_t* req); -int uv__iou_fs_fsync_or_fdatasync(uv_loop_t* loop, - uv_fs_t* req, - uint32_t fsync_flags); -int uv__iou_fs_link(uv_loop_t* loop, uv_fs_t* req); -int uv__iou_fs_mkdir(uv_loop_t* loop, uv_fs_t* req); -int uv__iou_fs_open(uv_loop_t* loop, uv_fs_t* req); -int uv__iou_fs_read_or_write(uv_loop_t* loop, - uv_fs_t* req, - int is_read); -int uv__iou_fs_rename(uv_loop_t* loop, uv_fs_t* req); -int uv__iou_fs_statx(uv_loop_t* loop, - uv_fs_t* req, - int is_fstat, - int is_lstat); -int uv__iou_fs_symlink(uv_loop_t* loop, uv_fs_t* req); -int uv__iou_fs_unlink(uv_loop_t* loop, uv_fs_t* req); -#else -#define uv__iou_fs_close(loop, req) 0 -#define uv__iou_fs_fsync_or_fdatasync(loop, req, fsync_flags) 0 -#define uv__iou_fs_link(loop, req) 0 -#define uv__iou_fs_mkdir(loop, req) 0 -#define uv__iou_fs_open(loop, req) 0 -#define uv__iou_fs_read_or_write(loop, req, is_read) 0 -#define uv__iou_fs_rename(loop, req) 0 -#define uv__iou_fs_statx(loop, req, is_fstat, is_lstat) 0 -#define uv__iou_fs_symlink(loop, req) 0 -#define uv__iou_fs_unlink(loop, req) 0 -#endif - #if defined(__APPLE__) int uv___stream_fd(const uv_stream_t* handle); #define uv__stream_fd(handle) (uv___stream_fd((const uv_stream_t*) (handle))) @@ -394,53 +324,8 @@ UV_UNUSED(static char* uv__basename_r(const char* path)) { return s + 1; } -UV_UNUSED(static int uv__fstat(int fd, struct stat* s)) { - int rc; - - rc = fstat(fd, s); - if (rc >= 0) - uv__msan_unpoison(s, sizeof(*s)); - - return rc; -} - -UV_UNUSED(static int uv__lstat(const char* path, struct stat* s)) { - int rc; - - rc = lstat(path, s); - if (rc >= 0) - uv__msan_unpoison(s, sizeof(*s)); - - return rc; -} - -UV_UNUSED(static int uv__stat(const char* path, struct stat* s)) { - int rc; - - rc = stat(path, s); - if (rc >= 0) - uv__msan_unpoison(s, sizeof(*s)); - - return rc; -} - #if defined(__linux__) -void uv__fs_post(uv_loop_t* loop, uv_fs_t* req); -ssize_t -uv__fs_copy_file_range(int fd_in, - off_t* off_in, - int fd_out, - off_t* off_out, - size_t len, - unsigned int flags); -int uv__statx(int dirfd, - const char* path, - int flags, - unsigned int mask, - struct uv__statx* statxbuf); -void uv__statx_to_stat(const struct uv__statx* statxbuf, uv_stat_t* buf); -ssize_t uv__getrandom(void* buf, size_t buflen, unsigned flags); -unsigned uv__kernel_version(void); +int uv__inotify_fork(uv_loop_t* loop, void* old_watchers); #endif typedef int (*uv__peersockfunc)(int, struct sockaddr*, socklen_t*); @@ -450,6 +335,22 @@ int uv__getsockpeername(const uv_handle_t* handle, struct sockaddr* name, int* namelen); +#if defined(__linux__) || \ + defined(__FreeBSD__) || \ + defined(__FreeBSD_kernel__) || \ + defined(__DragonFly__) +#define HAVE_MMSG 1 +struct uv__mmsghdr { + struct msghdr msg_hdr; + unsigned int msg_len; +}; + +int uv__recvmmsg(int fd, struct uv__mmsghdr* mmsg, unsigned int vlen); +int uv__sendmmsg(int fd, struct uv__mmsghdr* mmsg, unsigned int vlen); +#else +#define HAVE_MMSG 0 +#endif + #if defined(__sun) #if !defined(_POSIX_VERSION) || _POSIX_VERSION < 200809L size_t strnlen(const char* s, size_t maxlen); @@ -466,10 +367,5 @@ uv__fs_copy_file_range(int fd_in, unsigned int flags); #endif -#if defined(__linux__) || (defined(__FreeBSD__) && __FreeBSD_version >= 1301000) -#define UV__CPU_AFFINITY_SUPPORTED 1 -#else -#define UV__CPU_AFFINITY_SUPPORTED 0 -#endif #endif /* UV_UNIX_INTERNAL_H_ */ diff --git a/src/unix/kqueue.c b/src/unix/kqueue.c index 4d09edc..5dac76a 100644 --- a/src/unix/kqueue.c +++ b/src/unix/kqueue.c @@ -30,9 +30,6 @@ #include #include #include -#if defined(__FreeBSD__) -#include -#endif #include #include #include @@ -63,7 +60,7 @@ int uv__kqueue_init(uv_loop_t* loop) { #if defined(__APPLE__) && MAC_OS_X_VERSION_MAX_ALLOWED >= 1070 -static _Atomic int uv__has_forked_with_cfrunloop; +static int uv__has_forked_with_cfrunloop; #endif int uv__io_fork(uv_loop_t* loop) { @@ -85,9 +82,7 @@ int uv__io_fork(uv_loop_t* loop) { process. So we sidestep the issue by pretending like we never started it in the first place. */ - atomic_store_explicit(&uv__has_forked_with_cfrunloop, - 1, - memory_order_relaxed); + uv__store_relaxed(&uv__has_forked_with_cfrunloop, 1); uv__free(loop->cf_state); loop->cf_state = NULL; } @@ -114,29 +109,13 @@ int uv__io_check_fd(uv_loop_t* loop, int fd) { } -static void uv__kqueue_delete(int kqfd, const struct kevent *ev) { - struct kevent change; - - EV_SET(&change, ev->ident, ev->filter, EV_DELETE, 0, 0, 0); - - if (0 == kevent(kqfd, &change, 1, NULL, 0, NULL)) - return; - - if (errno == EBADF || errno == ENOENT) - return; - - abort(); -} - - void uv__io_poll(uv_loop_t* loop, int timeout) { - uv__loop_internal_fields_t* lfields; struct kevent events[1024]; struct kevent* ev; struct timespec spec; unsigned int nevents; unsigned int revents; - struct uv__queue* q; + QUEUE* q; uv__io_t* w; uv_process_t* process; sigset_t* pset; @@ -155,19 +134,18 @@ void uv__io_poll(uv_loop_t* loop, int timeout) { int reset_timeout; if (loop->nfds == 0) { - assert(uv__queue_empty(&loop->watcher_queue)); + assert(QUEUE_EMPTY(&loop->watcher_queue)); return; } - lfields = uv__get_internal_fields(loop); nevents = 0; - while (!uv__queue_empty(&loop->watcher_queue)) { - q = uv__queue_head(&loop->watcher_queue); - uv__queue_remove(q); - uv__queue_init(q); + while (!QUEUE_EMPTY(&loop->watcher_queue)) { + q = QUEUE_HEAD(&loop->watcher_queue); + QUEUE_REMOVE(q); + QUEUE_INIT(q); - w = uv__queue_data(q, uv__io_t, watcher_queue); + w = QUEUE_DATA(q, uv__io_t, watcher_queue); assert(w->pevents != 0); assert(w->fd >= 0); assert(w->fd < (int) loop->nwatchers); @@ -227,7 +205,7 @@ void uv__io_poll(uv_loop_t* loop, int timeout) { base = loop->time; count = 48; /* Benchmarks suggest this gives the best throughput. */ - if (lfields->flags & UV_METRICS_IDLE_TIME) { + if (uv__get_internal_fields(loop)->flags & UV_METRICS_IDLE_TIME) { reset_timeout = 1; user_timeout = timeout; timeout = 0; @@ -250,12 +228,6 @@ void uv__io_poll(uv_loop_t* loop, int timeout) { if (pset != NULL) pthread_sigmask(SIG_BLOCK, pset, NULL); - /* Store the current timeout in a location that's globally accessible so - * other locations like uv__work_done() can determine whether the queue - * of events in the callback were waiting when poll was called. - */ - lfields->current_timeout = timeout; - nfds = kevent(loop->backend_fd, events, nevents, @@ -263,12 +235,6 @@ void uv__io_poll(uv_loop_t* loop, int timeout) { ARRAY_SIZE(events), timeout == -1 ? NULL : &spec); - if (nfds == -1) - assert(errno == EINTR); - else if (nfds == 0) - /* Unlimited timeout should only return with events or signal. */ - assert(timeout != -1); - if (pset != NULL) pthread_sigmask(SIG_UNBLOCK, pset, NULL); @@ -276,25 +242,37 @@ void uv__io_poll(uv_loop_t* loop, int timeout) { * timeout == 0 (i.e. non-blocking poll) but there is no guarantee that the * operating system didn't reschedule our process while in the syscall. */ - uv__update_time(loop); - - if (nfds == 0 || nfds == -1) { - /* If kqueue is empty or interrupted, we might still have children ready - * to reap immediately. */ - if (loop->flags & UV_LOOP_REAP_CHILDREN) { - loop->flags &= ~UV_LOOP_REAP_CHILDREN; - uv__wait_children(loop); - assert((reset_timeout == 0 ? timeout : user_timeout) == 0); - return; /* Equivalent to fall-through behavior. */ + SAVE_ERRNO(uv__update_time(loop)); + + if (nfds == 0) { + if (reset_timeout != 0) { + timeout = user_timeout; + reset_timeout = 0; + if (timeout == -1) + continue; + if (timeout > 0) + goto update_timeout; } + assert(timeout != -1); + return; + } + + if (nfds == -1) { + if (errno != EINTR) + abort(); + if (reset_timeout != 0) { timeout = user_timeout; reset_timeout = 0; - } else if (nfds == 0) { - return; } + if (timeout == 0) + return; + + if (timeout == -1) + continue; + /* Interrupted by a signal. Update timeout and poll again. */ goto update_timeout; } @@ -311,8 +289,8 @@ void uv__io_poll(uv_loop_t* loop, int timeout) { /* Handle kevent NOTE_EXIT results */ if (ev->filter == EVFILT_PROC) { - uv__queue_foreach(q, &loop->process_handles) { - process = uv__queue_data(q, uv_process_t, queue); + QUEUE_FOREACH(q, &loop->process_handles) { + process = QUEUE_DATA(q, uv_process_t, queue); if (process->pid == fd) { process->flags |= UV_HANDLE_REAP; loop->flags |= UV_LOOP_REAP_CHILDREN; @@ -329,8 +307,15 @@ void uv__io_poll(uv_loop_t* loop, int timeout) { w = loop->watchers[fd]; if (w == NULL) { - /* File descriptor that we've stopped watching, disarm it. */ - uv__kqueue_delete(loop->backend_fd, ev); + /* File descriptor that we've stopped watching, disarm it. + * TODO: batch up. */ + struct kevent events[1]; + + EV_SET(events + 0, fd, ev->filter, EV_DELETE, 0, 0, 0); + if (kevent(loop->backend_fd, events, 1, NULL, 0, NULL)) + if (errno != EBADF && errno != ENOENT) + abort(); + continue; } @@ -346,27 +331,47 @@ void uv__io_poll(uv_loop_t* loop, int timeout) { revents = 0; if (ev->filter == EVFILT_READ) { - if (w->pevents & POLLIN) + if (w->pevents & POLLIN) { revents |= POLLIN; - else - uv__kqueue_delete(loop->backend_fd, ev); - + w->rcount = ev->data; + } else { + /* TODO batch up */ + struct kevent events[1]; + EV_SET(events + 0, fd, ev->filter, EV_DELETE, 0, 0, 0); + if (kevent(loop->backend_fd, events, 1, NULL, 0, NULL)) + if (errno != ENOENT) + abort(); + } if ((ev->flags & EV_EOF) && (w->pevents & UV__POLLRDHUP)) revents |= UV__POLLRDHUP; } if (ev->filter == EV_OOBAND) { - if (w->pevents & UV__POLLPRI) + if (w->pevents & UV__POLLPRI) { revents |= UV__POLLPRI; - else - uv__kqueue_delete(loop->backend_fd, ev); + w->rcount = ev->data; + } else { + /* TODO batch up */ + struct kevent events[1]; + EV_SET(events + 0, fd, ev->filter, EV_DELETE, 0, 0, 0); + if (kevent(loop->backend_fd, events, 1, NULL, 0, NULL)) + if (errno != ENOENT) + abort(); + } } if (ev->filter == EVFILT_WRITE) { - if (w->pevents & POLLOUT) + if (w->pevents & POLLOUT) { revents |= POLLOUT; - else - uv__kqueue_delete(loop->backend_fd, ev); + w->wcount = ev->data; + } else { + /* TODO batch up */ + struct kevent events[1]; + EV_SET(events + 0, fd, ev->filter, EV_DELETE, 0, 0, 0); + if (kevent(loop->backend_fd, events, 1, NULL, 0, NULL)) + if (errno != ENOENT) + abort(); + } } if (ev->flags & EV_ERROR) @@ -393,11 +398,9 @@ void uv__io_poll(uv_loop_t* loop, int timeout) { uv__wait_children(loop); } - uv__metrics_inc_events(loop, nevents); if (reset_timeout != 0) { timeout = user_timeout; reset_timeout = 0; - uv__metrics_inc_events_waiting(loop, nevents); } if (have_signals != 0) { @@ -420,13 +423,13 @@ void uv__io_poll(uv_loop_t* loop, int timeout) { return; } -update_timeout: if (timeout == 0) return; if (timeout == -1) continue; +update_timeout: assert(timeout > 0); diff = loop->time - base; @@ -483,26 +486,6 @@ static void uv__fs_event(uv_loop_t* loop, uv__io_t* w, unsigned int fflags) { */ if (fcntl(handle->event_watcher.fd, F_GETPATH, pathbuf) == 0) path = uv__basename_r(pathbuf); -#elif defined(F_KINFO) - /* We try to get the file info reference from the file descriptor. - * the struct's kf_structsize must be initialised beforehand - * whether with the KINFO_FILE_SIZE constant or this way. - */ - struct stat statbuf; - struct kinfo_file kf; - - if (handle->event_watcher.fd != -1 && - (!uv__fstat(handle->event_watcher.fd, &statbuf) && !(statbuf.st_mode & S_IFDIR))) { - /* we are purposely not using KINFO_FILE_SIZE here - * as it is not available on non intl archs - * and here it gives 1392 too on intel. - * anyway, the man page also mentions we can proceed - * this way. - */ - kf.kf_structsize = sizeof(kf); - if (fcntl(handle->event_watcher.fd, F_KINFO, &kf) == 0) - path = uv__basename_r(kf.kf_path); - } #endif handle->cb(handle, path, events, 0); @@ -558,14 +541,13 @@ int uv_fs_event_start(uv_fs_event_t* handle, handle->realpath_len = 0; handle->cf_flags = flags; - if (uv__fstat(fd, &statbuf)) + if (fstat(fd, &statbuf)) goto fallback; /* FSEvents works only with directories */ if (!(statbuf.st_mode & S_IFDIR)) goto fallback; - if (0 == atomic_load_explicit(&uv__has_forked_with_cfrunloop, - memory_order_relaxed)) { + if (0 == uv__load_relaxed(&uv__has_forked_with_cfrunloop)) { int r; /* The fallback fd is no longer needed */ uv__close_nocheckstdio(fd); @@ -600,8 +582,7 @@ int uv_fs_event_stop(uv_fs_event_t* handle) { uv__handle_stop(handle); #if defined(__APPLE__) && MAC_OS_X_VERSION_MAX_ALLOWED >= 1070 - if (0 == atomic_load_explicit(&uv__has_forked_with_cfrunloop, - memory_order_relaxed)) + if (0 == uv__load_relaxed(&uv__has_forked_with_cfrunloop)) if (handle->cf_cb != NULL) r = uv__fsevents_close(handle); #endif diff --git a/src/unix/linux-core.c b/src/unix/linux-core.c new file mode 100644 index 0000000..23a7daf --- /dev/null +++ b/src/unix/linux-core.c @@ -0,0 +1,834 @@ +/* Copyright Joyent, Inc. and other Node contributors. All rights reserved. + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to + * deal in the Software without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS + * IN THE SOFTWARE. + */ + +/* We lean on the fact that POLL{IN,OUT,ERR,HUP} correspond with their + * EPOLL* counterparts. We use the POLL* variants in this file because that + * is what libuv uses elsewhere. + */ + +#include "uv.h" +#include "internal.h" + +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +#define HAVE_IFADDRS_H 1 + +# if defined(__ANDROID_API__) && __ANDROID_API__ < 24 +# undef HAVE_IFADDRS_H +#endif + +#ifdef __UCLIBC__ +# if __UCLIBC_MAJOR__ < 0 && __UCLIBC_MINOR__ < 9 && __UCLIBC_SUBLEVEL__ < 32 +# undef HAVE_IFADDRS_H +# endif +#endif + +#ifdef HAVE_IFADDRS_H +# include +# include +# include +# include +#endif /* HAVE_IFADDRS_H */ + +/* Available from 2.6.32 onwards. */ +#ifndef CLOCK_MONOTONIC_COARSE +# define CLOCK_MONOTONIC_COARSE 6 +#endif + +/* This is rather annoying: CLOCK_BOOTTIME lives in but we can't + * include that file because it conflicts with . We'll just have to + * define it ourselves. + */ +#ifndef CLOCK_BOOTTIME +# define CLOCK_BOOTTIME 7 +#endif + +static int read_models(unsigned int numcpus, uv_cpu_info_t* ci); +static int read_times(FILE* statfile_fp, + unsigned int numcpus, + uv_cpu_info_t* ci); +static void read_speeds(unsigned int numcpus, uv_cpu_info_t* ci); +static uint64_t read_cpufreq(unsigned int cpunum); + +int uv__platform_loop_init(uv_loop_t* loop) { + + loop->inotify_fd = -1; + loop->inotify_watchers = NULL; + + return uv__epoll_init(loop); +} + + +int uv__io_fork(uv_loop_t* loop) { + int err; + void* old_watchers; + + old_watchers = loop->inotify_watchers; + + uv__close(loop->backend_fd); + loop->backend_fd = -1; + uv__platform_loop_delete(loop); + + err = uv__platform_loop_init(loop); + if (err) + return err; + + return uv__inotify_fork(loop, old_watchers); +} + + +void uv__platform_loop_delete(uv_loop_t* loop) { + if (loop->inotify_fd == -1) return; + uv__io_stop(loop, &loop->inotify_read_watcher, POLLIN); + uv__close(loop->inotify_fd); + loop->inotify_fd = -1; +} + + + +uint64_t uv__hrtime(uv_clocktype_t type) { + static clock_t fast_clock_id = -1; + struct timespec t; + clock_t clock_id; + + /* Prefer CLOCK_MONOTONIC_COARSE if available but only when it has + * millisecond granularity or better. CLOCK_MONOTONIC_COARSE is + * serviced entirely from the vDSO, whereas CLOCK_MONOTONIC may + * decide to make a costly system call. + */ + /* TODO(bnoordhuis) Use CLOCK_MONOTONIC_COARSE for UV_CLOCK_PRECISE + * when it has microsecond granularity or better (unlikely). + */ + clock_id = CLOCK_MONOTONIC; + if (type != UV_CLOCK_FAST) + goto done; + + clock_id = uv__load_relaxed(&fast_clock_id); + if (clock_id != -1) + goto done; + + clock_id = CLOCK_MONOTONIC; + if (0 == clock_getres(CLOCK_MONOTONIC_COARSE, &t)) + if (t.tv_nsec <= 1 * 1000 * 1000) + clock_id = CLOCK_MONOTONIC_COARSE; + + uv__store_relaxed(&fast_clock_id, clock_id); + +done: + + if (clock_gettime(clock_id, &t)) + return 0; /* Not really possible. */ + + return t.tv_sec * (uint64_t) 1e9 + t.tv_nsec; +} + + +int uv_resident_set_memory(size_t* rss) { + char buf[1024]; + const char* s; + ssize_t n; + long val; + int fd; + int i; + + do + fd = open("/proc/self/stat", O_RDONLY); + while (fd == -1 && errno == EINTR); + + if (fd == -1) + return UV__ERR(errno); + + do + n = read(fd, buf, sizeof(buf) - 1); + while (n == -1 && errno == EINTR); + + uv__close(fd); + if (n == -1) + return UV__ERR(errno); + buf[n] = '\0'; + + s = strchr(buf, ' '); + if (s == NULL) + goto err; + + s += 1; + if (*s != '(') + goto err; + + s = strchr(s, ')'); + if (s == NULL) + goto err; + + for (i = 1; i <= 22; i++) { + s = strchr(s + 1, ' '); + if (s == NULL) + goto err; + } + + errno = 0; + val = strtol(s, NULL, 10); + if (errno != 0) + goto err; + if (val < 0) + goto err; + + *rss = val * getpagesize(); + return 0; + +err: + return UV_EINVAL; +} + +int uv_uptime(double* uptime) { + static volatile int no_clock_boottime; + char buf[128]; + struct timespec now; + int r; + + /* Try /proc/uptime first, then fallback to clock_gettime(). */ + + if (0 == uv__slurp("/proc/uptime", buf, sizeof(buf))) + if (1 == sscanf(buf, "%lf", uptime)) + return 0; + + /* Try CLOCK_BOOTTIME first, fall back to CLOCK_MONOTONIC if not available + * (pre-2.6.39 kernels). CLOCK_MONOTONIC doesn't increase when the system + * is suspended. + */ + if (no_clock_boottime) { + retry_clock_gettime: r = clock_gettime(CLOCK_MONOTONIC, &now); + } + else if ((r = clock_gettime(CLOCK_BOOTTIME, &now)) && errno == EINVAL) { + no_clock_boottime = 1; + goto retry_clock_gettime; + } + + if (r) + return UV__ERR(errno); + + *uptime = now.tv_sec; + return 0; +} + + +static int uv__cpu_num(FILE* statfile_fp, unsigned int* numcpus) { + unsigned int num; + char buf[1024]; + + if (!fgets(buf, sizeof(buf), statfile_fp)) + return UV_EIO; + + num = 0; + while (fgets(buf, sizeof(buf), statfile_fp)) { + if (strncmp(buf, "cpu", 3)) + break; + num++; + } + + if (num == 0) + return UV_EIO; + + *numcpus = num; + return 0; +} + + +int uv_cpu_info(uv_cpu_info_t** cpu_infos, int* count) { + unsigned int numcpus; + uv_cpu_info_t* ci; + int err; + FILE* statfile_fp; + + *cpu_infos = NULL; + *count = 0; + + statfile_fp = uv__open_file("/proc/stat"); + if (statfile_fp == NULL) + return UV__ERR(errno); + + err = uv__cpu_num(statfile_fp, &numcpus); + if (err < 0) + goto out; + + err = UV_ENOMEM; + ci = uv__calloc(numcpus, sizeof(*ci)); + if (ci == NULL) + goto out; + + err = read_models(numcpus, ci); + if (err == 0) + err = read_times(statfile_fp, numcpus, ci); + + if (err) { + uv_free_cpu_info(ci, numcpus); + goto out; + } + + /* read_models() on x86 also reads the CPU speed from /proc/cpuinfo. + * We don't check for errors here. Worst case, the field is left zero. + */ + if (ci[0].speed == 0) + read_speeds(numcpus, ci); + + *cpu_infos = ci; + *count = numcpus; + err = 0; + +out: + + if (fclose(statfile_fp)) + if (errno != EINTR && errno != EINPROGRESS) + abort(); + + return err; +} + + +static void read_speeds(unsigned int numcpus, uv_cpu_info_t* ci) { + unsigned int num; + + for (num = 0; num < numcpus; num++) + ci[num].speed = read_cpufreq(num) / 1000; +} + + +/* Also reads the CPU frequency on ppc and x86. The other architectures only + * have a BogoMIPS field, which may not be very accurate. + * + * Note: Simply returns on error, uv_cpu_info() takes care of the cleanup. + */ +static int read_models(unsigned int numcpus, uv_cpu_info_t* ci) { +#if defined(__PPC__) + static const char model_marker[] = "cpu\t\t: "; + static const char speed_marker[] = "clock\t\t: "; +#else + static const char model_marker[] = "model name\t: "; + static const char speed_marker[] = "cpu MHz\t\t: "; +#endif + const char* inferred_model; + unsigned int model_idx; + unsigned int speed_idx; + unsigned int part_idx; + char buf[1024]; + char* model; + FILE* fp; + int model_id; + + /* Most are unused on non-ARM, non-MIPS and non-x86 architectures. */ + (void) &model_marker; + (void) &speed_marker; + (void) &speed_idx; + (void) &part_idx; + (void) &model; + (void) &buf; + (void) &fp; + (void) &model_id; + + model_idx = 0; + speed_idx = 0; + part_idx = 0; + +#if defined(__arm__) || \ + defined(__i386__) || \ + defined(__mips__) || \ + defined(__aarch64__) || \ + defined(__PPC__) || \ + defined(__x86_64__) + fp = uv__open_file("/proc/cpuinfo"); + if (fp == NULL) + return UV__ERR(errno); + + while (fgets(buf, sizeof(buf), fp)) { + if (model_idx < numcpus) { + if (strncmp(buf, model_marker, sizeof(model_marker) - 1) == 0) { + model = buf + sizeof(model_marker) - 1; + model = uv__strndup(model, strlen(model) - 1); /* Strip newline. */ + if (model == NULL) { + fclose(fp); + return UV_ENOMEM; + } + ci[model_idx++].model = model; + continue; + } + } +#if defined(__arm__) || defined(__mips__) || defined(__aarch64__) + if (model_idx < numcpus) { +#if defined(__arm__) + /* Fallback for pre-3.8 kernels. */ + static const char model_marker[] = "Processor\t: "; +#elif defined(__aarch64__) + static const char part_marker[] = "CPU part\t: "; + + /* Adapted from: https://github.com/karelzak/util-linux */ + struct vendor_part { + const int id; + const char* name; + }; + + static const struct vendor_part arm_chips[] = { + { 0x811, "ARM810" }, + { 0x920, "ARM920" }, + { 0x922, "ARM922" }, + { 0x926, "ARM926" }, + { 0x940, "ARM940" }, + { 0x946, "ARM946" }, + { 0x966, "ARM966" }, + { 0xa20, "ARM1020" }, + { 0xa22, "ARM1022" }, + { 0xa26, "ARM1026" }, + { 0xb02, "ARM11 MPCore" }, + { 0xb36, "ARM1136" }, + { 0xb56, "ARM1156" }, + { 0xb76, "ARM1176" }, + { 0xc05, "Cortex-A5" }, + { 0xc07, "Cortex-A7" }, + { 0xc08, "Cortex-A8" }, + { 0xc09, "Cortex-A9" }, + { 0xc0d, "Cortex-A17" }, /* Originally A12 */ + { 0xc0f, "Cortex-A15" }, + { 0xc0e, "Cortex-A17" }, + { 0xc14, "Cortex-R4" }, + { 0xc15, "Cortex-R5" }, + { 0xc17, "Cortex-R7" }, + { 0xc18, "Cortex-R8" }, + { 0xc20, "Cortex-M0" }, + { 0xc21, "Cortex-M1" }, + { 0xc23, "Cortex-M3" }, + { 0xc24, "Cortex-M4" }, + { 0xc27, "Cortex-M7" }, + { 0xc60, "Cortex-M0+" }, + { 0xd01, "Cortex-A32" }, + { 0xd03, "Cortex-A53" }, + { 0xd04, "Cortex-A35" }, + { 0xd05, "Cortex-A55" }, + { 0xd06, "Cortex-A65" }, + { 0xd07, "Cortex-A57" }, + { 0xd08, "Cortex-A72" }, + { 0xd09, "Cortex-A73" }, + { 0xd0a, "Cortex-A75" }, + { 0xd0b, "Cortex-A76" }, + { 0xd0c, "Neoverse-N1" }, + { 0xd0d, "Cortex-A77" }, + { 0xd0e, "Cortex-A76AE" }, + { 0xd13, "Cortex-R52" }, + { 0xd20, "Cortex-M23" }, + { 0xd21, "Cortex-M33" }, + { 0xd41, "Cortex-A78" }, + { 0xd42, "Cortex-A78AE" }, + { 0xd4a, "Neoverse-E1" }, + { 0xd4b, "Cortex-A78C" }, + }; + + if (strncmp(buf, part_marker, sizeof(part_marker) - 1) == 0) { + model = buf + sizeof(part_marker) - 1; + + errno = 0; + model_id = strtol(model, NULL, 16); + if ((errno != 0) || model_id < 0) { + fclose(fp); + return UV_EINVAL; + } + + for (part_idx = 0; part_idx < ARRAY_SIZE(arm_chips); part_idx++) { + if (model_id == arm_chips[part_idx].id) { + model = uv__strdup(arm_chips[part_idx].name); + if (model == NULL) { + fclose(fp); + return UV_ENOMEM; + } + ci[model_idx++].model = model; + break; + } + } + } +#else /* defined(__mips__) */ + static const char model_marker[] = "cpu model\t\t: "; +#endif + if (strncmp(buf, model_marker, sizeof(model_marker) - 1) == 0) { + model = buf + sizeof(model_marker) - 1; + model = uv__strndup(model, strlen(model) - 1); /* Strip newline. */ + if (model == NULL) { + fclose(fp); + return UV_ENOMEM; + } + ci[model_idx++].model = model; + continue; + } + } +#else /* !__arm__ && !__mips__ && !__aarch64__ */ + if (speed_idx < numcpus) { + if (strncmp(buf, speed_marker, sizeof(speed_marker) - 1) == 0) { + ci[speed_idx++].speed = atoi(buf + sizeof(speed_marker) - 1); + continue; + } + } +#endif /* __arm__ || __mips__ || __aarch64__ */ + } + + fclose(fp); +#endif /* __arm__ || __i386__ || __mips__ || __PPC__ || __x86_64__ || __aarch__ */ + + /* Now we want to make sure that all the models contain *something* because + * it's not safe to leave them as null. Copy the last entry unless there + * isn't one, in that case we simply put "unknown" into everything. + */ + inferred_model = "unknown"; + if (model_idx > 0) + inferred_model = ci[model_idx - 1].model; + + while (model_idx < numcpus) { + model = uv__strndup(inferred_model, strlen(inferred_model)); + if (model == NULL) + return UV_ENOMEM; + ci[model_idx++].model = model; + } + + return 0; +} + + +static int read_times(FILE* statfile_fp, + unsigned int numcpus, + uv_cpu_info_t* ci) { + struct uv_cpu_times_s ts; + unsigned int ticks; + unsigned int multiplier; + uint64_t user; + uint64_t nice; + uint64_t sys; + uint64_t idle; + uint64_t dummy; + uint64_t irq; + uint64_t num; + uint64_t len; + char buf[1024]; + + ticks = (unsigned int)sysconf(_SC_CLK_TCK); + assert(ticks != (unsigned int) -1); + assert(ticks != 0); + multiplier = ((uint64_t)1000L / ticks); + + rewind(statfile_fp); + + if (!fgets(buf, sizeof(buf), statfile_fp)) + abort(); + + num = 0; + + while (fgets(buf, sizeof(buf), statfile_fp)) { + if (num >= numcpus) + break; + + if (strncmp(buf, "cpu", 3)) + break; + + /* skip "cpu " marker */ + { + unsigned int n; + int r = sscanf(buf, "cpu%u ", &n); + assert(r == 1); + (void) r; /* silence build warning */ + for (len = sizeof("cpu0"); n /= 10; len++); + } + + /* Line contains user, nice, system, idle, iowait, irq, softirq, steal, + * guest, guest_nice but we're only interested in the first four + irq. + * + * Don't use %*s to skip fields or %ll to read straight into the uint64_t + * fields, they're not allowed in C89 mode. + */ + if (6 != sscanf(buf + len, + "%" PRIu64 " %" PRIu64 " %" PRIu64 + "%" PRIu64 " %" PRIu64 " %" PRIu64, + &user, + &nice, + &sys, + &idle, + &dummy, + &irq)) + abort(); + + ts.user = user * multiplier; + ts.nice = nice * multiplier; + ts.sys = sys * multiplier; + ts.idle = idle * multiplier; + ts.irq = irq * multiplier; + ci[num++].cpu_times = ts; + } + assert(num == numcpus); + + return 0; +} + + +static uint64_t read_cpufreq(unsigned int cpunum) { + uint64_t val; + char buf[1024]; + FILE* fp; + + snprintf(buf, + sizeof(buf), + "/sys/devices/system/cpu/cpu%u/cpufreq/scaling_cur_freq", + cpunum); + + fp = uv__open_file(buf); + if (fp == NULL) + return 0; + + if (fscanf(fp, "%" PRIu64, &val) != 1) + val = 0; + + fclose(fp); + + return val; +} + + +#ifdef HAVE_IFADDRS_H +static int uv__ifaddr_exclude(struct ifaddrs *ent, int exclude_type) { + if (!((ent->ifa_flags & IFF_UP) && (ent->ifa_flags & IFF_RUNNING))) + return 1; + if (ent->ifa_addr == NULL) + return 1; + /* + * On Linux getifaddrs returns information related to the raw underlying + * devices. We're not interested in this information yet. + */ + if (ent->ifa_addr->sa_family == PF_PACKET) + return exclude_type; + return !exclude_type; +} +#endif + +int uv_interface_addresses(uv_interface_address_t** addresses, int* count) { +#ifndef HAVE_IFADDRS_H + *count = 0; + *addresses = NULL; + return UV_ENOSYS; +#else + struct ifaddrs *addrs, *ent; + uv_interface_address_t* address; + int i; + struct sockaddr_ll *sll; + + *count = 0; + *addresses = NULL; + + if (getifaddrs(&addrs)) + return UV__ERR(errno); + + /* Count the number of interfaces */ + for (ent = addrs; ent != NULL; ent = ent->ifa_next) { + if (uv__ifaddr_exclude(ent, UV__EXCLUDE_IFADDR)) + continue; + + (*count)++; + } + + if (*count == 0) { + freeifaddrs(addrs); + return 0; + } + + /* Make sure the memory is initiallized to zero using calloc() */ + *addresses = uv__calloc(*count, sizeof(**addresses)); + if (!(*addresses)) { + freeifaddrs(addrs); + return UV_ENOMEM; + } + + address = *addresses; + + for (ent = addrs; ent != NULL; ent = ent->ifa_next) { + if (uv__ifaddr_exclude(ent, UV__EXCLUDE_IFADDR)) + continue; + + address->name = uv__strdup(ent->ifa_name); + + if (ent->ifa_addr->sa_family == AF_INET6) { + address->address.address6 = *((struct sockaddr_in6*) ent->ifa_addr); + } else { + address->address.address4 = *((struct sockaddr_in*) ent->ifa_addr); + } + + if (ent->ifa_netmask->sa_family == AF_INET6) { + address->netmask.netmask6 = *((struct sockaddr_in6*) ent->ifa_netmask); + } else { + address->netmask.netmask4 = *((struct sockaddr_in*) ent->ifa_netmask); + } + + address->is_internal = !!(ent->ifa_flags & IFF_LOOPBACK); + + address++; + } + + /* Fill in physical addresses for each interface */ + for (ent = addrs; ent != NULL; ent = ent->ifa_next) { + if (uv__ifaddr_exclude(ent, UV__EXCLUDE_IFPHYS)) + continue; + + address = *addresses; + + for (i = 0; i < (*count); i++) { + size_t namelen = strlen(ent->ifa_name); + /* Alias interface share the same physical address */ + if (strncmp(address->name, ent->ifa_name, namelen) == 0 && + (address->name[namelen] == 0 || address->name[namelen] == ':')) { + sll = (struct sockaddr_ll*)ent->ifa_addr; + memcpy(address->phys_addr, sll->sll_addr, sizeof(address->phys_addr)); + } + address++; + } + } + + freeifaddrs(addrs); + + return 0; +#endif +} + + +void uv_free_interface_addresses(uv_interface_address_t* addresses, + int count) { + int i; + + for (i = 0; i < count; i++) { + uv__free(addresses[i].name); + } + + uv__free(addresses); +} + + +void uv__set_process_title(const char* title) { +#if defined(PR_SET_NAME) + prctl(PR_SET_NAME, title); /* Only copies first 16 characters. */ +#endif +} + + +static uint64_t uv__read_proc_meminfo(const char* what) { + uint64_t rc; + char* p; + char buf[4096]; /* Large enough to hold all of /proc/meminfo. */ + + if (uv__slurp("/proc/meminfo", buf, sizeof(buf))) + return 0; + + p = strstr(buf, what); + + if (p == NULL) + return 0; + + p += strlen(what); + + rc = 0; + sscanf(p, "%" PRIu64 " kB", &rc); + + return rc * 1024; +} + + +uint64_t uv_get_free_memory(void) { + struct sysinfo info; + uint64_t rc; + + rc = uv__read_proc_meminfo("MemAvailable:"); + + if (rc != 0) + return rc; + + if (0 == sysinfo(&info)) + return (uint64_t) info.freeram * info.mem_unit; + + return 0; +} + + +uint64_t uv_get_total_memory(void) { + struct sysinfo info; + uint64_t rc; + + rc = uv__read_proc_meminfo("MemTotal:"); + + if (rc != 0) + return rc; + + if (0 == sysinfo(&info)) + return (uint64_t) info.totalram * info.mem_unit; + + return 0; +} + + +static uint64_t uv__read_cgroups_uint64(const char* cgroup, const char* param) { + char filename[256]; + char buf[32]; /* Large enough to hold an encoded uint64_t. */ + uint64_t rc; + + rc = 0; + snprintf(filename, sizeof(filename), "/sys/fs/cgroup/%s/%s", cgroup, param); + if (0 == uv__slurp(filename, buf, sizeof(buf))) + sscanf(buf, "%" PRIu64, &rc); + + return rc; +} + + +uint64_t uv_get_constrained_memory(void) { + /* + * This might return 0 if there was a problem getting the memory limit from + * cgroups. This is OK because a return value of 0 signifies that the memory + * limit is unknown. + */ + return uv__read_cgroups_uint64("memory", "memory.limit_in_bytes"); +} + + +void uv_loadavg(double avg[3]) { + struct sysinfo info; + char buf[128]; /* Large enough to hold all of /proc/loadavg. */ + + if (0 == uv__slurp("/proc/loadavg", buf, sizeof(buf))) + if (3 == sscanf(buf, "%lf %lf %lf", &avg[0], &avg[1], &avg[2])) + return; + + if (sysinfo(&info) < 0) + return; + + avg[0] = (double) info.loads[0] / 65536.0; + avg[1] = (double) info.loads[1] / 65536.0; + avg[2] = (double) info.loads[2] / 65536.0; +} diff --git a/src/unix/linux-inotify.c b/src/unix/linux-inotify.c new file mode 100644 index 0000000..c1bd260 --- /dev/null +++ b/src/unix/linux-inotify.c @@ -0,0 +1,327 @@ +/* Copyright Joyent, Inc. and other Node contributors. All rights reserved. + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to + * deal in the Software without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS + * IN THE SOFTWARE. + */ + +#include "uv.h" +#include "uv/tree.h" +#include "internal.h" + +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +struct watcher_list { + RB_ENTRY(watcher_list) entry; + QUEUE watchers; + int iterating; + char* path; + int wd; +}; + +struct watcher_root { + struct watcher_list* rbh_root; +}; +#define CAST(p) ((struct watcher_root*)(p)) + + +static int compare_watchers(const struct watcher_list* a, + const struct watcher_list* b) { + if (a->wd < b->wd) return -1; + if (a->wd > b->wd) return 1; + return 0; +} + + +RB_GENERATE_STATIC(watcher_root, watcher_list, entry, compare_watchers) + + +static void uv__inotify_read(uv_loop_t* loop, + uv__io_t* w, + unsigned int revents); + +static void maybe_free_watcher_list(struct watcher_list* w, + uv_loop_t* loop); + +static int init_inotify(uv_loop_t* loop) { + int fd; + + if (loop->inotify_fd != -1) + return 0; + + fd = inotify_init1(IN_NONBLOCK | IN_CLOEXEC); + if (fd < 0) + return UV__ERR(errno); + + loop->inotify_fd = fd; + uv__io_init(&loop->inotify_read_watcher, uv__inotify_read, loop->inotify_fd); + uv__io_start(loop, &loop->inotify_read_watcher, POLLIN); + + return 0; +} + + +int uv__inotify_fork(uv_loop_t* loop, void* old_watchers) { + /* Open the inotify_fd, and re-arm all the inotify watchers. */ + int err; + struct watcher_list* tmp_watcher_list_iter; + struct watcher_list* watcher_list; + struct watcher_list tmp_watcher_list; + QUEUE queue; + QUEUE* q; + uv_fs_event_t* handle; + char* tmp_path; + + if (old_watchers != NULL) { + /* We must restore the old watcher list to be able to close items + * out of it. + */ + loop->inotify_watchers = old_watchers; + + QUEUE_INIT(&tmp_watcher_list.watchers); + /* Note that the queue we use is shared with the start and stop() + * functions, making QUEUE_FOREACH unsafe to use. So we use the + * QUEUE_MOVE trick to safely iterate. Also don't free the watcher + * list until we're done iterating. c.f. uv__inotify_read. + */ + RB_FOREACH_SAFE(watcher_list, watcher_root, + CAST(&old_watchers), tmp_watcher_list_iter) { + watcher_list->iterating = 1; + QUEUE_MOVE(&watcher_list->watchers, &queue); + while (!QUEUE_EMPTY(&queue)) { + q = QUEUE_HEAD(&queue); + handle = QUEUE_DATA(q, uv_fs_event_t, watchers); + /* It's critical to keep a copy of path here, because it + * will be set to NULL by stop() and then deallocated by + * maybe_free_watcher_list + */ + tmp_path = uv__strdup(handle->path); + assert(tmp_path != NULL); + QUEUE_REMOVE(q); + QUEUE_INSERT_TAIL(&watcher_list->watchers, q); + uv_fs_event_stop(handle); + + QUEUE_INSERT_TAIL(&tmp_watcher_list.watchers, &handle->watchers); + handle->path = tmp_path; + } + watcher_list->iterating = 0; + maybe_free_watcher_list(watcher_list, loop); + } + + QUEUE_MOVE(&tmp_watcher_list.watchers, &queue); + while (!QUEUE_EMPTY(&queue)) { + q = QUEUE_HEAD(&queue); + QUEUE_REMOVE(q); + handle = QUEUE_DATA(q, uv_fs_event_t, watchers); + tmp_path = handle->path; + handle->path = NULL; + err = uv_fs_event_start(handle, handle->cb, tmp_path, 0); + uv__free(tmp_path); + if (err) + return err; + } + } + + return 0; +} + + +static struct watcher_list* find_watcher(uv_loop_t* loop, int wd) { + struct watcher_list w; + w.wd = wd; + return RB_FIND(watcher_root, CAST(&loop->inotify_watchers), &w); +} + +static void maybe_free_watcher_list(struct watcher_list* w, uv_loop_t* loop) { + /* if the watcher_list->watchers is being iterated over, we can't free it. */ + if ((!w->iterating) && QUEUE_EMPTY(&w->watchers)) { + /* No watchers left for this path. Clean up. */ + RB_REMOVE(watcher_root, CAST(&loop->inotify_watchers), w); + inotify_rm_watch(loop->inotify_fd, w->wd); + uv__free(w); + } +} + +static void uv__inotify_read(uv_loop_t* loop, + uv__io_t* dummy, + unsigned int events) { + const struct inotify_event* e; + struct watcher_list* w; + uv_fs_event_t* h; + QUEUE queue; + QUEUE* q; + const char* path; + ssize_t size; + const char *p; + /* needs to be large enough for sizeof(inotify_event) + strlen(path) */ + char buf[4096]; + + for (;;) { + do + size = read(loop->inotify_fd, buf, sizeof(buf)); + while (size == -1 && errno == EINTR); + + if (size == -1) { + assert(errno == EAGAIN || errno == EWOULDBLOCK); + break; + } + + assert(size > 0); /* pre-2.6.21 thing, size=0 == read buffer too small */ + + /* Now we have one or more inotify_event structs. */ + for (p = buf; p < buf + size; p += sizeof(*e) + e->len) { + e = (const struct inotify_event*) p; + + events = 0; + if (e->mask & (IN_ATTRIB|IN_MODIFY)) + events |= UV_CHANGE; + if (e->mask & ~(IN_ATTRIB|IN_MODIFY)) + events |= UV_RENAME; + + w = find_watcher(loop, e->wd); + if (w == NULL) + continue; /* Stale event, no watchers left. */ + + /* inotify does not return the filename when monitoring a single file + * for modifications. Repurpose the filename for API compatibility. + * I'm not convinced this is a good thing, maybe it should go. + */ + path = e->len ? (const char*) (e + 1) : uv__basename_r(w->path); + + /* We're about to iterate over the queue and call user's callbacks. + * What can go wrong? + * A callback could call uv_fs_event_stop() + * and the queue can change under our feet. + * So, we use QUEUE_MOVE() trick to safely iterate over the queue. + * And we don't free the watcher_list until we're done iterating. + * + * First, + * tell uv_fs_event_stop() (that could be called from a user's callback) + * not to free watcher_list. + */ + w->iterating = 1; + QUEUE_MOVE(&w->watchers, &queue); + while (!QUEUE_EMPTY(&queue)) { + q = QUEUE_HEAD(&queue); + h = QUEUE_DATA(q, uv_fs_event_t, watchers); + + QUEUE_REMOVE(q); + QUEUE_INSERT_TAIL(&w->watchers, q); + + h->cb(h, path, events, 0); + } + /* done iterating, time to (maybe) free empty watcher_list */ + w->iterating = 0; + maybe_free_watcher_list(w, loop); + } + } +} + + +int uv_fs_event_init(uv_loop_t* loop, uv_fs_event_t* handle) { + uv__handle_init(loop, (uv_handle_t*)handle, UV_FS_EVENT); + return 0; +} + + +int uv_fs_event_start(uv_fs_event_t* handle, + uv_fs_event_cb cb, + const char* path, + unsigned int flags) { + struct watcher_list* w; + size_t len; + int events; + int err; + int wd; + + if (uv__is_active(handle)) + return UV_EINVAL; + + err = init_inotify(handle->loop); + if (err) + return err; + + events = IN_ATTRIB + | IN_CREATE + | IN_MODIFY + | IN_DELETE + | IN_DELETE_SELF + | IN_MOVE_SELF + | IN_MOVED_FROM + | IN_MOVED_TO; + + wd = inotify_add_watch(handle->loop->inotify_fd, path, events); + if (wd == -1) + return UV__ERR(errno); + + w = find_watcher(handle->loop, wd); + if (w) + goto no_insert; + + len = strlen(path) + 1; + w = uv__malloc(sizeof(*w) + len); + if (w == NULL) + return UV_ENOMEM; + + w->wd = wd; + w->path = memcpy(w + 1, path, len); + QUEUE_INIT(&w->watchers); + w->iterating = 0; + RB_INSERT(watcher_root, CAST(&handle->loop->inotify_watchers), w); + +no_insert: + uv__handle_start(handle); + QUEUE_INSERT_TAIL(&w->watchers, &handle->watchers); + handle->path = w->path; + handle->cb = cb; + handle->wd = wd; + + return 0; +} + + +int uv_fs_event_stop(uv_fs_event_t* handle) { + struct watcher_list* w; + + if (!uv__is_active(handle)) + return 0; + + w = find_watcher(handle->loop, handle->wd); + assert(w != NULL); + + handle->wd = -1; + handle->path = NULL; + uv__handle_stop(handle); + QUEUE_REMOVE(&handle->watchers); + + maybe_free_watcher_list(w, handle->loop); + + return 0; +} + + +void uv__fs_event_close(uv_fs_event_t* handle) { + uv_fs_event_stop(handle); +} diff --git a/src/unix/linux-syscalls.c b/src/unix/linux-syscalls.c new file mode 100644 index 0000000..5071cd5 --- /dev/null +++ b/src/unix/linux-syscalls.c @@ -0,0 +1,264 @@ +/* Copyright Joyent, Inc. and other Node contributors. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to + * deal in the Software without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS + * IN THE SOFTWARE. + */ + +#include "linux-syscalls.h" +#include +#include +#include +#include +#include + +#if defined(__arm__) +# if defined(__thumb__) || defined(__ARM_EABI__) +# define UV_SYSCALL_BASE 0 +# else +# define UV_SYSCALL_BASE 0x900000 +# endif +#endif /* __arm__ */ + +#ifndef __NR_recvmmsg +# if defined(__x86_64__) +# define __NR_recvmmsg 299 +# elif defined(__arm__) +# define __NR_recvmmsg (UV_SYSCALL_BASE + 365) +# endif +#endif /* __NR_recvmsg */ + +#ifndef __NR_sendmmsg +# if defined(__x86_64__) +# define __NR_sendmmsg 307 +# elif defined(__arm__) +# define __NR_sendmmsg (UV_SYSCALL_BASE + 374) +# endif +#endif /* __NR_sendmmsg */ + +#ifndef __NR_utimensat +# if defined(__x86_64__) +# define __NR_utimensat 280 +# elif defined(__i386__) +# define __NR_utimensat 320 +# elif defined(__arm__) +# define __NR_utimensat (UV_SYSCALL_BASE + 348) +# endif +#endif /* __NR_utimensat */ + +#ifndef __NR_preadv +# if defined(__x86_64__) +# define __NR_preadv 295 +# elif defined(__i386__) +# define __NR_preadv 333 +# elif defined(__arm__) +# define __NR_preadv (UV_SYSCALL_BASE + 361) +# endif +#endif /* __NR_preadv */ + +#ifndef __NR_pwritev +# if defined(__x86_64__) +# define __NR_pwritev 296 +# elif defined(__i386__) +# define __NR_pwritev 334 +# elif defined(__arm__) +# define __NR_pwritev (UV_SYSCALL_BASE + 362) +# endif +#endif /* __NR_pwritev */ + +#ifndef __NR_dup3 +# if defined(__x86_64__) +# define __NR_dup3 292 +# elif defined(__i386__) +# define __NR_dup3 330 +# elif defined(__arm__) +# define __NR_dup3 (UV_SYSCALL_BASE + 358) +# endif +#endif /* __NR_pwritev */ + +#ifndef __NR_copy_file_range +# if defined(__x86_64__) +# define __NR_copy_file_range 326 +# elif defined(__i386__) +# define __NR_copy_file_range 377 +# elif defined(__s390__) +# define __NR_copy_file_range 375 +# elif defined(__arm__) +# define __NR_copy_file_range (UV_SYSCALL_BASE + 391) +# elif defined(__aarch64__) +# define __NR_copy_file_range 285 +# elif defined(__powerpc__) +# define __NR_copy_file_range 379 +# elif defined(__arc__) +# define __NR_copy_file_range 285 +# endif +#endif /* __NR_copy_file_range */ + +#ifndef __NR_statx +# if defined(__x86_64__) +# define __NR_statx 332 +# elif defined(__i386__) +# define __NR_statx 383 +# elif defined(__aarch64__) +# define __NR_statx 397 +# elif defined(__arm__) +# define __NR_statx (UV_SYSCALL_BASE + 397) +# elif defined(__ppc__) +# define __NR_statx 383 +# elif defined(__s390__) +# define __NR_statx 379 +# endif +#endif /* __NR_statx */ + +#ifndef __NR_getrandom +# if defined(__x86_64__) +# define __NR_getrandom 318 +# elif defined(__i386__) +# define __NR_getrandom 355 +# elif defined(__aarch64__) +# define __NR_getrandom 384 +# elif defined(__arm__) +# define __NR_getrandom (UV_SYSCALL_BASE + 384) +# elif defined(__ppc__) +# define __NR_getrandom 359 +# elif defined(__s390__) +# define __NR_getrandom 349 +# endif +#endif /* __NR_getrandom */ + +struct uv__mmsghdr; + +int uv__sendmmsg(int fd, struct uv__mmsghdr* mmsg, unsigned int vlen) { +#if defined(__i386__) + unsigned long args[4]; + int rc; + + args[0] = (unsigned long) fd; + args[1] = (unsigned long) mmsg; + args[2] = (unsigned long) vlen; + args[3] = /* flags */ 0; + + /* socketcall() raises EINVAL when SYS_SENDMMSG is not supported. */ + rc = syscall(/* __NR_socketcall */ 102, 20 /* SYS_SENDMMSG */, args); + if (rc == -1) + if (errno == EINVAL) + errno = ENOSYS; + + return rc; +#elif defined(__NR_sendmmsg) + return syscall(__NR_sendmmsg, fd, mmsg, vlen, /* flags */ 0); +#else + return errno = ENOSYS, -1; +#endif +} + + +int uv__recvmmsg(int fd, struct uv__mmsghdr* mmsg, unsigned int vlen) { +#if defined(__i386__) + unsigned long args[5]; + int rc; + + args[0] = (unsigned long) fd; + args[1] = (unsigned long) mmsg; + args[2] = (unsigned long) vlen; + args[3] = /* flags */ 0; + args[4] = /* timeout */ 0; + + /* socketcall() raises EINVAL when SYS_RECVMMSG is not supported. */ + rc = syscall(/* __NR_socketcall */ 102, 19 /* SYS_RECVMMSG */, args); + if (rc == -1) + if (errno == EINVAL) + errno = ENOSYS; + + return rc; +#elif defined(__NR_recvmmsg) + return syscall(__NR_recvmmsg, fd, mmsg, vlen, /* flags */ 0, /* timeout */ 0); +#else + return errno = ENOSYS, -1; +#endif +} + + +ssize_t uv__preadv(int fd, const struct iovec *iov, int iovcnt, int64_t offset) { +#if !defined(__NR_preadv) || defined(__ANDROID_API__) && __ANDROID_API__ < 24 + return errno = ENOSYS, -1; +#else + return syscall(__NR_preadv, fd, iov, iovcnt, (long)offset, (long)(offset >> 32)); +#endif +} + + +ssize_t uv__pwritev(int fd, const struct iovec *iov, int iovcnt, int64_t offset) { +#if !defined(__NR_pwritev) || defined(__ANDROID_API__) && __ANDROID_API__ < 24 + return errno = ENOSYS, -1; +#else + return syscall(__NR_pwritev, fd, iov, iovcnt, (long)offset, (long)(offset >> 32)); +#endif +} + + +int uv__dup3(int oldfd, int newfd, int flags) { +#if !defined(__NR_dup3) || defined(__ANDROID_API__) && __ANDROID_API__ < 21 + return errno = ENOSYS, -1; +#else + return syscall(__NR_dup3, oldfd, newfd, flags); +#endif +} + + +ssize_t +uv__fs_copy_file_range(int fd_in, + off_t* off_in, + int fd_out, + off_t* off_out, + size_t len, + unsigned int flags) +{ +#ifdef __NR_copy_file_range + return syscall(__NR_copy_file_range, + fd_in, + off_in, + fd_out, + off_out, + len, + flags); +#else + return errno = ENOSYS, -1; +#endif +} + + +int uv__statx(int dirfd, + const char* path, + int flags, + unsigned int mask, + struct uv__statx* statxbuf) { +#if !defined(__NR_statx) || defined(__ANDROID_API__) && __ANDROID_API__ < 30 + return errno = ENOSYS, -1; +#else + return syscall(__NR_statx, dirfd, path, flags, mask, statxbuf); +#endif +} + + +ssize_t uv__getrandom(void* buf, size_t buflen, unsigned flags) { +#if !defined(__NR_getrandom) || defined(__ANDROID_API__) && __ANDROID_API__ < 28 + return errno = ENOSYS, -1; +#else + return syscall(__NR_getrandom, buf, buflen, flags); +#endif +} diff --git a/test/test-thread-priority.c b/src/unix/linux-syscalls.h similarity index 36% rename from test/test-thread-priority.c rename to src/unix/linux-syscalls.h index 0aaf297..b4d9082 100644 --- a/test/test-thread-priority.c +++ b/src/unix/linux-syscalls.h @@ -1,4 +1,4 @@ -/* Copyright libuv contributors. All rights reserved. +/* Copyright Joyent, Inc. and other Node contributors. All rights reserved. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to @@ -19,87 +19,60 @@ * IN THE SOFTWARE. */ -#include "uv.h" -#include "task.h" - -#include -#include -#include /* memset */ - -#ifdef __POSIX__ -#include -#include -#endif - -#ifdef _WIN32 -#include -#else -#include -#endif - -uv_sem_t sem; - -static void simple_task(void *args) { - uv_sem_wait(&sem); - printf("in simple_task\n"); -} - -TEST_IMPL(thread_priority) { - int priority; -#ifndef _WIN32 - int min; - int max; - int policy; - struct sched_param param; -#endif - uv_thread_t task_id; - - /* Verify that passing a NULL pointer returns UV_EINVAL. */ - ASSERT_EQ(UV_EINVAL, uv_thread_getpriority(0, NULL)); - ASSERT_OK(uv_sem_init(&sem, 1)); - uv_sem_wait(&sem); - ASSERT_OK(uv_thread_create(&task_id, simple_task, NULL)); - ASSERT_OK(uv_thread_getpriority(task_id, &priority)); - -#ifdef _WIN32 - ASSERT_EQ(priority, THREAD_PRIORITY_NORMAL); -#else - ASSERT_OK(pthread_getschedparam(task_id, &policy, ¶m)); -#ifdef __PASE__ - min = 1; - max = 127; -#else - min = sched_get_priority_min(policy); - max = sched_get_priority_max(policy); -#endif - ASSERT(priority >= min && priority <= max); -#endif - - ASSERT_OK(uv_thread_setpriority(task_id, UV_THREAD_PRIORITY_LOWEST)); - ASSERT_OK(uv_thread_getpriority(task_id, &priority)); - -#ifdef _WIN32 - ASSERT_EQ(priority, THREAD_PRIORITY_LOWEST); -#else - ASSERT_EQ(priority, min); -#endif - -/** - * test set nice value for the calling thread with default schedule policy -*/ -#ifdef __linux__ - ASSERT_OK(uv_thread_getpriority(pthread_self(), &priority)); - ASSERT_EQ(priority, 0); - ASSERT_OK(uv_thread_setpriority(pthread_self(), UV_THREAD_PRIORITY_LOWEST)); - ASSERT_OK(uv_thread_getpriority(pthread_self(), &priority)); - ASSERT_EQ(priority, (0 - UV_THREAD_PRIORITY_LOWEST * 2)); -#endif - - uv_sem_post(&sem); - - ASSERT_OK(uv_thread_join(&task_id)); - - uv_sem_destroy(&sem); - - return 0; -} \ No newline at end of file +#ifndef UV_LINUX_SYSCALL_H_ +#define UV_LINUX_SYSCALL_H_ + +#include +#include +#include +#include +#include + +struct uv__statx_timestamp { + int64_t tv_sec; + uint32_t tv_nsec; + int32_t unused0; +}; + +struct uv__statx { + uint32_t stx_mask; + uint32_t stx_blksize; + uint64_t stx_attributes; + uint32_t stx_nlink; + uint32_t stx_uid; + uint32_t stx_gid; + uint16_t stx_mode; + uint16_t unused0; + uint64_t stx_ino; + uint64_t stx_size; + uint64_t stx_blocks; + uint64_t stx_attributes_mask; + struct uv__statx_timestamp stx_atime; + struct uv__statx_timestamp stx_btime; + struct uv__statx_timestamp stx_ctime; + struct uv__statx_timestamp stx_mtime; + uint32_t stx_rdev_major; + uint32_t stx_rdev_minor; + uint32_t stx_dev_major; + uint32_t stx_dev_minor; + uint64_t unused1[14]; +}; + +ssize_t uv__preadv(int fd, const struct iovec *iov, int iovcnt, int64_t offset); +ssize_t uv__pwritev(int fd, const struct iovec *iov, int iovcnt, int64_t offset); +int uv__dup3(int oldfd, int newfd, int flags); +ssize_t +uv__fs_copy_file_range(int fd_in, + off_t* off_in, + int fd_out, + off_t* off_out, + size_t len, + unsigned int flags); +int uv__statx(int dirfd, + const char* path, + int flags, + unsigned int mask, + struct uv__statx* statxbuf); +ssize_t uv__getrandom(void* buf, size_t buflen, unsigned flags); + +#endif /* UV_LINUX_SYSCALL_H_ */ diff --git a/src/unix/linux.c b/src/unix/linux.c deleted file mode 100644 index 0c5468b..0000000 --- a/src/unix/linux.c +++ /dev/null @@ -1,2597 +0,0 @@ -/* Copyright Joyent, Inc. and other Node contributors. All rights reserved. - * Permission is hereby granted, free of charge, to any person obtaining a copy - * of this software and associated documentation files (the "Software"), to - * deal in the Software without restriction, including without limitation the - * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or - * sell copies of the Software, and to permit persons to whom the Software is - * furnished to do so, subject to the following conditions: - * - * The above copyright notice and this permission notice shall be included in - * all copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING - * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS - * IN THE SOFTWARE. - */ - -/* We lean on the fact that POLL{IN,OUT,ERR,HUP} correspond with their - * EPOLL* counterparts. We use the POLL* variants in this file because that - * is what libuv uses elsewhere. - */ - -#include "uv.h" -#include "internal.h" -#include "uv_log.h" -#include -#include -#include /* offsetof */ -#include -#include -#include -#include -#include -#include - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#ifdef USE_FFRT -#include "ffrt.h" -#include "c/executor_task.h" - -int uv__epoll_wait(struct epoll_event* events, int eventsize, uint64_t timeout) { - int nfds = 0; - if (ffrt_get_cur_task() != NULL) { - ffrt_qos_t qos = ffrt_this_task_get_qos(); - nfds = ffrt_epoll_wait(qos, events, eventsize, timeout); - } - return nfds; -} -#endif - -int uv__epoll_ctl(int epoll_fd, int op, int fd, struct epoll_event* event) { -#ifdef USE_FFRT - if (ffrt_get_cur_task() != NULL) { - ffrt_qos_t qos = ffrt_this_task_get_qos(); - return ffrt_epoll_ctl(qos, op, fd, event->events, NULL, NULL); - } -#endif - return epoll_ctl(epoll_fd, op, fd ,event); -} -#ifndef __NR_io_uring_setup -# define __NR_io_uring_setup 425 -#endif - -#ifndef __NR_io_uring_enter -# define __NR_io_uring_enter 426 -#endif - -#ifndef __NR_io_uring_register -# define __NR_io_uring_register 427 -#endif - -#ifndef __NR_copy_file_range -# if defined(__x86_64__) -# define __NR_copy_file_range 326 -# elif defined(__i386__) -# define __NR_copy_file_range 377 -# elif defined(__s390__) -# define __NR_copy_file_range 375 -# elif defined(__arm__) -# define __NR_copy_file_range 391 -# elif defined(__aarch64__) -# define __NR_copy_file_range 285 -# elif defined(__powerpc__) -# define __NR_copy_file_range 379 -# elif defined(__arc__) -# define __NR_copy_file_range 285 -# elif defined(__riscv) -# define __NR_copy_file_range 285 -# endif -#endif /* __NR_copy_file_range */ - -#ifndef __NR_statx -# if defined(__x86_64__) -# define __NR_statx 332 -# elif defined(__i386__) -# define __NR_statx 383 -# elif defined(__aarch64__) -# define __NR_statx 397 -# elif defined(__arm__) -# define __NR_statx 397 -# elif defined(__ppc__) -# define __NR_statx 383 -# elif defined(__s390__) -# define __NR_statx 379 -# elif defined(__riscv) -# define __NR_statx 291 -# endif -#endif /* __NR_statx */ - -#ifndef __NR_getrandom -# if defined(__x86_64__) -# define __NR_getrandom 318 -# elif defined(__i386__) -# define __NR_getrandom 355 -# elif defined(__aarch64__) -# define __NR_getrandom 384 -# elif defined(__arm__) -# define __NR_getrandom 384 -# elif defined(__ppc__) -# define __NR_getrandom 359 -# elif defined(__s390__) -# define __NR_getrandom 349 -# elif defined(__riscv) -# define __NR_getrandom 278 -# endif -#endif /* __NR_getrandom */ - -enum { - UV__IORING_SETUP_SQPOLL = 2u, -}; - -enum { - UV__IORING_FEAT_SINGLE_MMAP = 1u, - UV__IORING_FEAT_NODROP = 2u, - UV__IORING_FEAT_RSRC_TAGS = 1024u, /* linux v5.13 */ -}; - -enum { - UV__IORING_OP_READV = 1, - UV__IORING_OP_WRITEV = 2, - UV__IORING_OP_FSYNC = 3, - UV__IORING_OP_OPENAT = 18, - UV__IORING_OP_CLOSE = 19, - UV__IORING_OP_STATX = 21, - UV__IORING_OP_EPOLL_CTL = 29, - UV__IORING_OP_RENAMEAT = 35, - UV__IORING_OP_UNLINKAT = 36, - UV__IORING_OP_MKDIRAT = 37, - UV__IORING_OP_SYMLINKAT = 38, - UV__IORING_OP_LINKAT = 39, -}; - -enum { - UV__IORING_ENTER_GETEVENTS = 1u, - UV__IORING_ENTER_SQ_WAKEUP = 2u, -}; - -enum { - UV__IORING_SQ_NEED_WAKEUP = 1u, - UV__IORING_SQ_CQ_OVERFLOW = 2u, -}; - -enum { - UV__MKDIRAT_SYMLINKAT_LINKAT = 1u, -}; - -struct uv__io_cqring_offsets { - uint32_t head; - uint32_t tail; - uint32_t ring_mask; - uint32_t ring_entries; - uint32_t overflow; - uint32_t cqes; - uint64_t reserved0; - uint64_t reserved1; -}; - -STATIC_ASSERT(40 == sizeof(struct uv__io_cqring_offsets)); - -struct uv__io_sqring_offsets { - uint32_t head; - uint32_t tail; - uint32_t ring_mask; - uint32_t ring_entries; - uint32_t flags; - uint32_t dropped; - uint32_t array; - uint32_t reserved0; - uint64_t reserved1; -}; - -STATIC_ASSERT(40 == sizeof(struct uv__io_sqring_offsets)); - -struct uv__io_uring_cqe { - uint64_t user_data; - int32_t res; - uint32_t flags; -}; - -STATIC_ASSERT(16 == sizeof(struct uv__io_uring_cqe)); - -struct uv__io_uring_sqe { - uint8_t opcode; - uint8_t flags; - uint16_t ioprio; - int32_t fd; - union { - uint64_t off; - uint64_t addr2; - }; - union { - uint64_t addr; - }; - uint32_t len; - union { - uint32_t rw_flags; - uint32_t fsync_flags; - uint32_t open_flags; - uint32_t statx_flags; - }; - uint64_t user_data; - union { - uint16_t buf_index; - uint64_t pad[3]; - }; -}; - -STATIC_ASSERT(64 == sizeof(struct uv__io_uring_sqe)); -STATIC_ASSERT(0 == offsetof(struct uv__io_uring_sqe, opcode)); -STATIC_ASSERT(1 == offsetof(struct uv__io_uring_sqe, flags)); -STATIC_ASSERT(2 == offsetof(struct uv__io_uring_sqe, ioprio)); -STATIC_ASSERT(4 == offsetof(struct uv__io_uring_sqe, fd)); -STATIC_ASSERT(8 == offsetof(struct uv__io_uring_sqe, off)); -STATIC_ASSERT(16 == offsetof(struct uv__io_uring_sqe, addr)); -STATIC_ASSERT(24 == offsetof(struct uv__io_uring_sqe, len)); -STATIC_ASSERT(28 == offsetof(struct uv__io_uring_sqe, rw_flags)); -STATIC_ASSERT(32 == offsetof(struct uv__io_uring_sqe, user_data)); -STATIC_ASSERT(40 == offsetof(struct uv__io_uring_sqe, buf_index)); - -struct uv__io_uring_params { - uint32_t sq_entries; - uint32_t cq_entries; - uint32_t flags; - uint32_t sq_thread_cpu; - uint32_t sq_thread_idle; - uint32_t features; - uint32_t reserved[4]; - struct uv__io_sqring_offsets sq_off; /* 40 bytes */ - struct uv__io_cqring_offsets cq_off; /* 40 bytes */ -}; - -STATIC_ASSERT(40 + 40 + 40 == sizeof(struct uv__io_uring_params)); -STATIC_ASSERT(40 == offsetof(struct uv__io_uring_params, sq_off)); -STATIC_ASSERT(80 == offsetof(struct uv__io_uring_params, cq_off)); - -STATIC_ASSERT(EPOLL_CTL_ADD < 4); -STATIC_ASSERT(EPOLL_CTL_DEL < 4); -STATIC_ASSERT(EPOLL_CTL_MOD < 4); - -struct watcher_list { - RB_ENTRY(watcher_list) entry; - struct uv__queue watchers; - int iterating; - char* path; - int wd; -}; - -struct watcher_root { - struct watcher_list* rbh_root; -}; - -static int uv__inotify_fork(uv_loop_t* loop, struct watcher_list* root); -static void uv__inotify_read(uv_loop_t* loop, - uv__io_t* w, - unsigned int revents); -static int compare_watchers(const struct watcher_list* a, - const struct watcher_list* b); -static void maybe_free_watcher_list(struct watcher_list* w, - uv_loop_t* loop); - -static void uv__epoll_ctl_flush(int epollfd, - struct uv__iou* ctl, - struct epoll_event (*events)[256]); - -static void uv__epoll_ctl_prep(int epollfd, - struct uv__iou* ctl, - struct epoll_event (*events)[256], - int op, - int fd, - struct epoll_event* e); - -RB_GENERATE_STATIC(watcher_root, watcher_list, entry, compare_watchers) - - -static struct watcher_root* uv__inotify_watchers(uv_loop_t* loop) { - /* This cast works because watcher_root is a struct with a pointer as its - * sole member. Such type punning is unsafe in the presence of strict - * pointer aliasing (and is just plain nasty) but that is why libuv - * is compiled with -fno-strict-aliasing. - */ - return (struct watcher_root*) &loop->inotify_watchers; -} - - -unsigned uv__kernel_version(void) { - static _Atomic unsigned cached_version; - struct utsname u; - unsigned version; - unsigned major; - unsigned minor; - unsigned patch; - char v_sig[256]; - char* needle; - - version = atomic_load_explicit(&cached_version, memory_order_relaxed); - if (version != 0) - return version; - - /* Check /proc/version_signature first as it's the way to get the mainline - * kernel version in Ubuntu. The format is: - * Ubuntu ubuntu_kernel_version mainline_kernel_version - * For example: - * Ubuntu 5.15.0-79.86-generic 5.15.111 - */ - if (0 == uv__slurp("/proc/version_signature", v_sig, sizeof(v_sig))) - if (3 == sscanf(v_sig, "Ubuntu %*s %u.%u.%u", &major, &minor, &patch)) - goto calculate_version; - - if (-1 == uname(&u)) - return 0; - - /* In Debian we need to check `version` instead of `release` to extract the - * mainline kernel version. This is an example of how it looks like: - * #1 SMP Debian 5.10.46-4 (2021-08-03) - */ - needle = strstr(u.version, "Debian "); - if (needle != NULL) - if (3 == sscanf(needle, "Debian %u.%u.%u", &major, &minor, &patch)) - goto calculate_version; - - if (3 != sscanf(u.release, "%u.%u.%u", &major, &minor, &patch)) - return 0; - - /* Handle it when the process runs under the UNAME26 personality: - * - * - kernels >= 3.x identify as 2.6.40+x - * - kernels >= 4.x identify as 2.6.60+x - * - * UNAME26 is a poorly conceived hack that doesn't let us distinguish - * between 4.x kernels and 5.x/6.x kernels so we conservatively assume - * that 2.6.60+x means 4.x. - * - * Fun fact of the day: it's technically possible to observe the actual - * kernel version for a brief moment because uname() first copies out the - * real release string before overwriting it with the backcompat string. - */ - if (major == 2 && minor == 6) { - if (patch >= 60) { - major = 4; - minor = patch - 60; - patch = 0; - } else if (patch >= 40) { - major = 3; - minor = patch - 40; - patch = 0; - } - } - -calculate_version: - version = major * 65536 + minor * 256 + patch; - atomic_store_explicit(&cached_version, version, memory_order_relaxed); - - return version; -} - - -ssize_t -uv__fs_copy_file_range(int fd_in, - off_t* off_in, - int fd_out, - off_t* off_out, - size_t len, - unsigned int flags) -{ -#ifdef __NR_copy_file_range - return syscall(__NR_copy_file_range, - fd_in, - off_in, - fd_out, - off_out, - len, - flags); -#else - return errno = ENOSYS, -1; -#endif -} - - -int uv__statx(int dirfd, - const char* path, - int flags, - unsigned int mask, - struct uv__statx* statxbuf) { -#if !defined(__NR_statx) || defined(__ANDROID_API__) && __ANDROID_API__ < 30 - return errno = ENOSYS, -1; -#else - int rc; - - rc = syscall(__NR_statx, dirfd, path, flags, mask, statxbuf); - if (rc >= 0) - uv__msan_unpoison(statxbuf, sizeof(*statxbuf)); - - return rc; -#endif -} - - -ssize_t uv__getrandom(void* buf, size_t buflen, unsigned flags) { -#if !defined(__NR_getrandom) || defined(__ANDROID_API__) && __ANDROID_API__ < 28 - return errno = ENOSYS, -1; -#else - ssize_t rc; - - rc = syscall(__NR_getrandom, buf, buflen, flags); - if (rc >= 0) - uv__msan_unpoison(buf, buflen); - - return rc; -#endif -} - - -int uv__io_uring_setup(int entries, struct uv__io_uring_params* params) { - return syscall(__NR_io_uring_setup, entries, params); -} - - -int uv__io_uring_enter(int fd, - unsigned to_submit, - unsigned min_complete, - unsigned flags) { - /* io_uring_enter used to take a sigset_t but it's unused - * in newer kernels unless IORING_ENTER_EXT_ARG is set, - * in which case it takes a struct io_uring_getevents_arg. - */ - return syscall(__NR_io_uring_enter, - fd, - to_submit, - min_complete, - flags, - NULL, - 0L); -} - - -int uv__io_uring_register(int fd, unsigned opcode, void* arg, unsigned nargs) { - return syscall(__NR_io_uring_register, fd, opcode, arg, nargs); -} - - -static int uv__use_io_uring(void) { -#if defined(__ANDROID_API__) - return 0; /* Possibly available but blocked by seccomp. */ -#elif defined(__arm__) && __SIZEOF_POINTER__ == 4 - /* See https://github.com/libuv/libuv/issues/4158. */ - return 0; /* All 32 bits kernels appear buggy. */ -#elif defined(__powerpc64__) || defined(__ppc64__) - /* See https://github.com/libuv/libuv/issues/4283. */ - return 0; /* Random SIGSEGV in signal handler. */ -#else - /* Ternary: unknown=0, yes=1, no=-1 */ - static _Atomic int use_io_uring; - char* val; - int use; - - use = atomic_load_explicit(&use_io_uring, memory_order_relaxed); - - if (use == 0) { - use = uv__kernel_version() >= -#if defined(__hppa__) - /* io_uring first supported on parisc in 6.1, functional in .51 */ - /* https://lore.kernel.org/all/cb912694-b1fe-dbb0-4d8c-d608f3526905@gmx.de/ */ - /* 6.1.51 */ 0x060133 -#else - /* Older kernels have a bug where the sqpoll thread uses 100% CPU. */ - /* 5.10.186 */ 0x050ABA -#endif - ? 1 : -1; - - /* But users can still enable it if they so desire. */ - val = getenv("UV_USE_IO_URING"); - if (val != NULL) - use = atoi(val) ? 1 : -1; - - atomic_store_explicit(&use_io_uring, use, memory_order_relaxed); - } - - return use > 0; -#endif -} - - -static void uv__iou_init(int epollfd, - struct uv__iou* iou, - uint32_t entries, - uint32_t flags) { - struct uv__io_uring_params params; - struct epoll_event e; - size_t cqlen; - size_t sqlen; - size_t maxlen; - size_t sqelen; - uint32_t i; - char* sq; - char* sqe; - int ringfd; - - sq = MAP_FAILED; - sqe = MAP_FAILED; - - if (!uv__use_io_uring()) - return; - - /* SQPOLL required CAP_SYS_NICE until linux v5.12 relaxed that requirement. - * Mostly academic because we check for a v5.13 kernel afterwards anyway. - */ - memset(¶ms, 0, sizeof(params)); - params.flags = flags; - - if (flags & UV__IORING_SETUP_SQPOLL) - params.sq_thread_idle = 10; /* milliseconds */ - - /* Kernel returns a file descriptor with O_CLOEXEC flag set. */ - ringfd = uv__io_uring_setup(entries, ¶ms); - if (ringfd == -1) - return; - - /* IORING_FEAT_RSRC_TAGS is used to detect linux v5.13 but what we're - * actually detecting is whether IORING_OP_STATX works with SQPOLL. - */ - if (!(params.features & UV__IORING_FEAT_RSRC_TAGS)) - goto fail; - - /* Implied by IORING_FEAT_RSRC_TAGS but checked explicitly anyway. */ - if (!(params.features & UV__IORING_FEAT_SINGLE_MMAP)) - goto fail; - - /* Implied by IORING_FEAT_RSRC_TAGS but checked explicitly anyway. */ - if (!(params.features & UV__IORING_FEAT_NODROP)) - goto fail; - - sqlen = params.sq_off.array + params.sq_entries * sizeof(uint32_t); - cqlen = - params.cq_off.cqes + params.cq_entries * sizeof(struct uv__io_uring_cqe); - maxlen = sqlen < cqlen ? cqlen : sqlen; - sqelen = params.sq_entries * sizeof(struct uv__io_uring_sqe); - - sq = mmap(0, - maxlen, - PROT_READ | PROT_WRITE, - MAP_SHARED | MAP_POPULATE, - ringfd, - 0); /* IORING_OFF_SQ_RING */ - - sqe = mmap(0, - sqelen, - PROT_READ | PROT_WRITE, - MAP_SHARED | MAP_POPULATE, - ringfd, - 0x10000000ull); /* IORING_OFF_SQES */ - - if (sq == MAP_FAILED || sqe == MAP_FAILED) - goto fail; - - if (flags & UV__IORING_SETUP_SQPOLL) { - /* Only interested in completion events. To get notified when - * the kernel pulls items from the submission ring, add POLLOUT. - */ - memset(&e, 0, sizeof(e)); - e.events = POLLIN; - e.data.fd = ringfd; - - if (uv__epoll_ctl(epollfd, EPOLL_CTL_ADD, ringfd, &e)) - goto fail; - } - - iou->sqhead = (uint32_t*) (sq + params.sq_off.head); - iou->sqtail = (uint32_t*) (sq + params.sq_off.tail); - iou->sqmask = *(uint32_t*) (sq + params.sq_off.ring_mask); - iou->sqarray = (uint32_t*) (sq + params.sq_off.array); - iou->sqflags = (uint32_t*) (sq + params.sq_off.flags); - iou->cqhead = (uint32_t*) (sq + params.cq_off.head); - iou->cqtail = (uint32_t*) (sq + params.cq_off.tail); - iou->cqmask = *(uint32_t*) (sq + params.cq_off.ring_mask); - iou->sq = sq; - iou->cqe = sq + params.cq_off.cqes; - iou->sqe = sqe; - iou->sqlen = sqlen; - iou->cqlen = cqlen; - iou->maxlen = maxlen; - iou->sqelen = sqelen; - iou->ringfd = ringfd; - iou->in_flight = 0; - iou->flags = 0; - - if (uv__kernel_version() >= /* 5.15.0 */ 0x050F00) - iou->flags |= UV__MKDIRAT_SYMLINKAT_LINKAT; - - for (i = 0; i <= iou->sqmask; i++) - iou->sqarray[i] = i; /* Slot -> sqe identity mapping. */ - - return; - -fail: - if (sq != MAP_FAILED) - munmap(sq, maxlen); - - if (sqe != MAP_FAILED) - munmap(sqe, sqelen); - - uv__close(ringfd); -} - - -static void uv__iou_delete(struct uv__iou* iou) { - if (iou->ringfd != -1) { - munmap(iou->sq, iou->maxlen); - munmap(iou->sqe, iou->sqelen); - uv__close(iou->ringfd); - iou->ringfd = -1; - } -} - - -int uv__platform_loop_init(uv_loop_t* loop) { - uv__loop_internal_fields_t* lfields; - - lfields = uv__get_internal_fields(loop); - lfields->ctl.ringfd = -1; - lfields->iou.ringfd = -1; - - loop->inotify_watchers = NULL; - loop->inotify_fd = -1; - loop->backend_fd = epoll_create1(O_CLOEXEC); -#ifdef USE_OHOS_DFX - fdsan_exchange_owner_tag(loop->backend_fd, 0, uv__get_addr_tag((void *)&loop->backend_fd)); -#endif - if (loop->backend_fd == -1) - return UV__ERR(errno); - - uv__iou_init(loop->backend_fd, &lfields->iou, 64, UV__IORING_SETUP_SQPOLL); - uv__iou_init(loop->backend_fd, &lfields->ctl, 256, 0); - UV_LOGI("loop init: loop add is %{public}zu, backend_fd is %{public}d", (size_t)loop, loop->backend_fd); - return 0; -} - - -int uv__io_fork(uv_loop_t* loop) { - int err; - struct watcher_list* root; - - root = uv__inotify_watchers(loop)->rbh_root; -#ifdef USE_OHOS_DFX - fdsan_close_with_tag(loop->backend_fd, uv__get_addr_tag((void *)&loop->backend_fd)); -#else - uv__close(loop->backend_fd); -#endif - loop->backend_fd = -1; - - /* TODO(bnoordhuis) Loses items from the submission and completion rings. */ - uv__platform_loop_delete(loop); - - err = uv__platform_loop_init(loop); - if (err) - return err; - - return uv__inotify_fork(loop, root); -} - - -void uv__platform_loop_delete(uv_loop_t* loop) { - uv__loop_internal_fields_t* lfields; - - lfields = uv__get_internal_fields(loop); - uv__iou_delete(&lfields->ctl); - uv__iou_delete(&lfields->iou); - - if (loop->inotify_fd != -1) { - uv__io_stop(loop, &loop->inotify_read_watcher, POLLIN); - uv__close(loop->inotify_fd); - loop->inotify_fd = -1; - } -} - - -struct uv__invalidate { - struct epoll_event (*prep)[256]; - struct epoll_event* events; - int nfds; -}; - - -void uv__platform_invalidate_fd(uv_loop_t* loop, int fd) { - uv__loop_internal_fields_t* lfields; - struct uv__invalidate* inv; - struct epoll_event dummy; - int i; - - lfields = uv__get_internal_fields(loop); - inv = lfields->inv; - - /* Invalidate events with same file descriptor */ - if (inv != NULL) - for (i = 0; i < inv->nfds; i++) - if (inv->events[i].data.fd == fd) - inv->events[i].data.fd = -1; - - /* Remove the file descriptor from the epoll. - * This avoids a problem where the same file description remains open - * in another process, causing repeated junk epoll events. - * - * We pass in a dummy epoll_event, to work around a bug in old kernels. - * - * Work around a bug in kernels 3.10 to 3.19 where passing a struct that - * has the EPOLLWAKEUP flag set generates spurious audit syslog warnings. - */ - memset(&dummy, 0, sizeof(dummy)); - - if (inv == NULL) { - uv__epoll_ctl(loop->backend_fd, EPOLL_CTL_DEL, fd, &dummy); - } else { - uv__epoll_ctl_prep(loop->backend_fd, - &lfields->ctl, - inv->prep, - EPOLL_CTL_DEL, - fd, - &dummy); - } -} - - -int uv__io_check_fd(uv_loop_t* loop, int fd) { - struct epoll_event e; - int rc; - - memset(&e, 0, sizeof(e)); - e.events = POLLIN; - e.data.fd = -1; - - rc = 0; - if (uv__epoll_ctl(loop->backend_fd, EPOLL_CTL_ADD, fd, &e)) - if (errno != EEXIST) - rc = UV__ERR(errno); - - if (rc == 0) - if (uv__epoll_ctl(loop->backend_fd, EPOLL_CTL_DEL, fd, &e)) - abort(); - - return rc; -} - - -/* Caller must initialize SQE and call uv__iou_submit(). */ -static struct uv__io_uring_sqe* uv__iou_get_sqe(struct uv__iou* iou, - uv_loop_t* loop, - uv_fs_t* req) { - struct uv__io_uring_sqe* sqe; - uint32_t head; - uint32_t tail; - uint32_t mask; - uint32_t slot; - - if (iou->ringfd == -1) - return NULL; - - head = atomic_load_explicit((_Atomic uint32_t*) iou->sqhead, - memory_order_acquire); - tail = *iou->sqtail; - mask = iou->sqmask; - - if ((head & mask) == ((tail + 1) & mask)) - return NULL; /* No room in ring buffer. TODO(bnoordhuis) maybe flush it? */ - - slot = tail & mask; - sqe = iou->sqe; - sqe = &sqe[slot]; - memset(sqe, 0, sizeof(*sqe)); - sqe->user_data = (uintptr_t) req; - - /* Pacify uv_cancel(). */ - req->work_req.loop = loop; - req->work_req.work = NULL; - req->work_req.done = NULL; - uv__queue_init(&req->work_req.wq); - - uv__req_register(loop, req); - iou->in_flight++; - - return sqe; -} - - -static void uv__iou_submit(struct uv__iou* iou) { - uint32_t flags; - - atomic_store_explicit((_Atomic uint32_t*) iou->sqtail, - *iou->sqtail + 1, - memory_order_release); - - flags = atomic_load_explicit((_Atomic uint32_t*) iou->sqflags, - memory_order_acquire); - - if (flags & UV__IORING_SQ_NEED_WAKEUP) - if (uv__io_uring_enter(iou->ringfd, 0, 0, UV__IORING_ENTER_SQ_WAKEUP)) - if (errno != EOWNERDEAD) /* Kernel bug. Harmless, ignore. */ - perror("libuv: io_uring_enter(wakeup)"); /* Can't happen. */ -} - - -int uv__iou_fs_close(uv_loop_t* loop, uv_fs_t* req) { - struct uv__io_uring_sqe* sqe; - struct uv__iou* iou; - int kv; - - kv = uv__kernel_version(); - /* Work around a poorly understood bug in older kernels where closing a file - * descriptor pointing to /foo/bar results in ETXTBSY errors when trying to - * execve("/foo/bar") later on. The bug seems to have been fixed somewhere - * between 5.15.85 and 5.15.90. I couldn't pinpoint the responsible commit - * but good candidates are the several data race fixes. Interestingly, it - * seems to manifest only when running under Docker so the possibility of - * a Docker bug can't be completely ruled out either. Yay, computers. - * Also, disable on non-longterm versions between 5.16.0 (non-longterm) and - * 6.1.0 (longterm). Starting with longterm 6.1.x, the issue seems to be - * solved. - */ - if (kv < /* 5.15.90 */ 0x050F5A) - return 0; - - if (kv >= /* 5.16.0 */ 0x050A00 && kv < /* 6.1.0 */ 0x060100) - return 0; - - - iou = &uv__get_internal_fields(loop)->iou; - - sqe = uv__iou_get_sqe(iou, loop, req); - if (sqe == NULL) - return 0; - - sqe->fd = req->file; - sqe->opcode = UV__IORING_OP_CLOSE; - - uv__iou_submit(iou); - - return 1; -} - - -int uv__iou_fs_fsync_or_fdatasync(uv_loop_t* loop, - uv_fs_t* req, - uint32_t fsync_flags) { - struct uv__io_uring_sqe* sqe; - struct uv__iou* iou; - - iou = &uv__get_internal_fields(loop)->iou; - - sqe = uv__iou_get_sqe(iou, loop, req); - if (sqe == NULL) - return 0; - - /* Little known fact: setting seq->off and seq->len turns - * it into an asynchronous sync_file_range() operation. - */ - sqe->fd = req->file; - sqe->fsync_flags = fsync_flags; - sqe->opcode = UV__IORING_OP_FSYNC; - - uv__iou_submit(iou); - - return 1; -} - - -int uv__iou_fs_link(uv_loop_t* loop, uv_fs_t* req) { - struct uv__io_uring_sqe* sqe; - struct uv__iou* iou; - - iou = &uv__get_internal_fields(loop)->iou; - - if (!(iou->flags & UV__MKDIRAT_SYMLINKAT_LINKAT)) - return 0; - - sqe = uv__iou_get_sqe(iou, loop, req); - if (sqe == NULL) - return 0; - - sqe->addr = (uintptr_t) req->path; - sqe->fd = AT_FDCWD; - sqe->addr2 = (uintptr_t) req->new_path; - sqe->len = AT_FDCWD; - sqe->opcode = UV__IORING_OP_LINKAT; - - uv__iou_submit(iou); - - return 1; -} - - -int uv__iou_fs_mkdir(uv_loop_t* loop, uv_fs_t* req) { - struct uv__io_uring_sqe* sqe; - struct uv__iou* iou; - - iou = &uv__get_internal_fields(loop)->iou; - - if (!(iou->flags & UV__MKDIRAT_SYMLINKAT_LINKAT)) - return 0; - - sqe = uv__iou_get_sqe(iou, loop, req); - if (sqe == NULL) - return 0; - - sqe->addr = (uintptr_t) req->path; - sqe->fd = AT_FDCWD; - sqe->len = req->mode; - sqe->opcode = UV__IORING_OP_MKDIRAT; - - uv__iou_submit(iou); - - return 1; -} - - -int uv__iou_fs_open(uv_loop_t* loop, uv_fs_t* req) { - struct uv__io_uring_sqe* sqe; - struct uv__iou* iou; - - iou = &uv__get_internal_fields(loop)->iou; - - sqe = uv__iou_get_sqe(iou, loop, req); - if (sqe == NULL) - return 0; - - sqe->addr = (uintptr_t) req->path; - sqe->fd = AT_FDCWD; - sqe->len = req->mode; - sqe->opcode = UV__IORING_OP_OPENAT; - sqe->open_flags = req->flags | O_CLOEXEC; - - uv__iou_submit(iou); - - return 1; -} - - -int uv__iou_fs_rename(uv_loop_t* loop, uv_fs_t* req) { - struct uv__io_uring_sqe* sqe; - struct uv__iou* iou; - - iou = &uv__get_internal_fields(loop)->iou; - - sqe = uv__iou_get_sqe(iou, loop, req); - if (sqe == NULL) - return 0; - - sqe->addr = (uintptr_t) req->path; - sqe->fd = AT_FDCWD; - sqe->addr2 = (uintptr_t) req->new_path; - sqe->len = AT_FDCWD; - sqe->opcode = UV__IORING_OP_RENAMEAT; - - uv__iou_submit(iou); - - return 1; -} - - -int uv__iou_fs_symlink(uv_loop_t* loop, uv_fs_t* req) { - struct uv__io_uring_sqe* sqe; - struct uv__iou* iou; - - iou = &uv__get_internal_fields(loop)->iou; - - if (!(iou->flags & UV__MKDIRAT_SYMLINKAT_LINKAT)) - return 0; - - sqe = uv__iou_get_sqe(iou, loop, req); - if (sqe == NULL) - return 0; - - sqe->addr = (uintptr_t) req->path; - sqe->fd = AT_FDCWD; - sqe->addr2 = (uintptr_t) req->new_path; - sqe->opcode = UV__IORING_OP_SYMLINKAT; - - uv__iou_submit(iou); - - return 1; -} - - -int uv__iou_fs_unlink(uv_loop_t* loop, uv_fs_t* req) { - struct uv__io_uring_sqe* sqe; - struct uv__iou* iou; - - iou = &uv__get_internal_fields(loop)->iou; - - sqe = uv__iou_get_sqe(iou, loop, req); - if (sqe == NULL) - return 0; - - sqe->addr = (uintptr_t) req->path; - sqe->fd = AT_FDCWD; - sqe->opcode = UV__IORING_OP_UNLINKAT; - - uv__iou_submit(iou); - - return 1; -} - - -int uv__iou_fs_read_or_write(uv_loop_t* loop, - uv_fs_t* req, - int is_read) { - struct uv__io_uring_sqe* sqe; - struct uv__iou* iou; - - /* If iovcnt is greater than IOV_MAX, cap it to IOV_MAX on reads and fallback - * to the threadpool on writes */ - if (req->nbufs > IOV_MAX) { - if (is_read) - req->nbufs = IOV_MAX; - else - return 0; - } - - iou = &uv__get_internal_fields(loop)->iou; - - sqe = uv__iou_get_sqe(iou, loop, req); - if (sqe == NULL) - return 0; - - sqe->addr = (uintptr_t) req->bufs; - sqe->fd = req->file; - sqe->len = req->nbufs; - sqe->off = req->off < 0 ? -1 : req->off; - sqe->opcode = is_read ? UV__IORING_OP_READV : UV__IORING_OP_WRITEV; - - uv__iou_submit(iou); - - return 1; -} - - -int uv__iou_fs_statx(uv_loop_t* loop, - uv_fs_t* req, - int is_fstat, - int is_lstat) { - struct uv__io_uring_sqe* sqe; - struct uv__statx* statxbuf; - struct uv__iou* iou; - - statxbuf = uv__malloc(sizeof(*statxbuf)); - if (statxbuf == NULL) - return 0; - - iou = &uv__get_internal_fields(loop)->iou; - - sqe = uv__iou_get_sqe(iou, loop, req); - if (sqe == NULL) { - uv__free(statxbuf); - return 0; - } - - req->ptr = statxbuf; - - sqe->addr = (uintptr_t) req->path; - sqe->addr2 = (uintptr_t) statxbuf; - sqe->fd = AT_FDCWD; - sqe->len = 0xFFF; /* STATX_BASIC_STATS + STATX_BTIME */ - sqe->opcode = UV__IORING_OP_STATX; - - if (is_fstat) { - sqe->addr = (uintptr_t) ""; - sqe->fd = req->file; - sqe->statx_flags |= 0x1000; /* AT_EMPTY_PATH */ - } - - if (is_lstat) - sqe->statx_flags |= AT_SYMLINK_NOFOLLOW; - - uv__iou_submit(iou); - - return 1; -} - - -void uv__statx_to_stat(const struct uv__statx* statxbuf, uv_stat_t* buf) { - buf->st_dev = makedev(statxbuf->stx_dev_major, statxbuf->stx_dev_minor); - buf->st_mode = statxbuf->stx_mode; - buf->st_nlink = statxbuf->stx_nlink; - buf->st_uid = statxbuf->stx_uid; - buf->st_gid = statxbuf->stx_gid; - buf->st_rdev = makedev(statxbuf->stx_rdev_major, statxbuf->stx_rdev_minor); - buf->st_ino = statxbuf->stx_ino; - buf->st_size = statxbuf->stx_size; - buf->st_blksize = statxbuf->stx_blksize; - buf->st_blocks = statxbuf->stx_blocks; - buf->st_atim.tv_sec = statxbuf->stx_atime.tv_sec; - buf->st_atim.tv_nsec = statxbuf->stx_atime.tv_nsec; - buf->st_mtim.tv_sec = statxbuf->stx_mtime.tv_sec; - buf->st_mtim.tv_nsec = statxbuf->stx_mtime.tv_nsec; - buf->st_ctim.tv_sec = statxbuf->stx_ctime.tv_sec; - buf->st_ctim.tv_nsec = statxbuf->stx_ctime.tv_nsec; - buf->st_birthtim.tv_sec = statxbuf->stx_btime.tv_sec; - buf->st_birthtim.tv_nsec = statxbuf->stx_btime.tv_nsec; - buf->st_flags = 0; - buf->st_gen = 0; -} - - -static void uv__iou_fs_statx_post(uv_fs_t* req) { - struct uv__statx* statxbuf; - uv_stat_t* buf; - - buf = &req->statbuf; - statxbuf = req->ptr; - req->ptr = NULL; - - if (req->result == 0) { - uv__msan_unpoison(statxbuf, sizeof(*statxbuf)); - uv__statx_to_stat(statxbuf, buf); - req->ptr = buf; - } - - uv__free(statxbuf); -} - - -static void uv__poll_io_uring(uv_loop_t* loop, struct uv__iou* iou) { - struct uv__io_uring_cqe* cqe; - struct uv__io_uring_cqe* e; - uv_fs_t* req; - uint32_t head; - uint32_t tail; - uint32_t mask; - uint32_t i; - uint32_t flags; - int nevents; - int rc; - - head = *iou->cqhead; - tail = atomic_load_explicit((_Atomic uint32_t*) iou->cqtail, - memory_order_acquire); - mask = iou->cqmask; - cqe = iou->cqe; - nevents = 0; - - for (i = head; i != tail; i++) { - e = &cqe[i & mask]; - - req = (uv_fs_t*) (uintptr_t) e->user_data; - assert(req->type == UV_FS); - - uv__req_unregister(loop, req); - iou->in_flight--; - - /* If the op is not supported by the kernel retry using the thread pool */ - if (e->res == -EOPNOTSUPP) { - uv__fs_post(loop, req); - continue; - } - - /* io_uring stores error codes as negative numbers, same as libuv. */ - req->result = e->res; - - switch (req->fs_type) { - case UV_FS_FSTAT: - case UV_FS_LSTAT: - case UV_FS_STAT: - uv__iou_fs_statx_post(req); - break; - default: /* Squelch -Wswitch warnings. */ - break; - } - - uv__metrics_update_idle_time(loop); - req->cb(req); - nevents++; - } - - atomic_store_explicit((_Atomic uint32_t*) iou->cqhead, - tail, - memory_order_release); - - /* Check whether CQE's overflowed, if so enter the kernel to make them - * available. Don't grab them immediately but in the next loop iteration to - * avoid loop starvation. */ - flags = atomic_load_explicit((_Atomic uint32_t*) iou->sqflags, - memory_order_acquire); - - if (flags & UV__IORING_SQ_CQ_OVERFLOW) { - do - rc = uv__io_uring_enter(iou->ringfd, 0, 0, UV__IORING_ENTER_GETEVENTS); - while (rc == -1 && errno == EINTR); - - if (rc < 0) - perror("libuv: io_uring_enter(getevents)"); /* Can't happen. */ - } - - uv__metrics_inc_events(loop, nevents); - if (uv__get_internal_fields(loop)->current_timeout == 0) - uv__metrics_inc_events_waiting(loop, nevents); -} - - -static void uv__epoll_ctl_prep(int epollfd, - struct uv__iou* ctl, - struct epoll_event (*events)[256], - int op, - int fd, - struct epoll_event* e) { - struct uv__io_uring_sqe* sqe; - struct epoll_event* pe; - uint32_t mask; - uint32_t slot; - - if (ctl->ringfd == -1) { - if (!uv__epoll_ctl(epollfd, op, fd, e)) - return; - - if (op == EPOLL_CTL_DEL) - return; /* Ignore errors, may be racing with another thread. */ - - if (op != EPOLL_CTL_ADD) - abort(); - - if (errno != EEXIST) - abort(); - - /* File descriptor that's been watched before, update event mask. */ - if (!epoll_ctl(epollfd, EPOLL_CTL_MOD, fd, e)) - return; - - abort(); - } else { - mask = ctl->sqmask; - slot = (*ctl->sqtail)++ & mask; - - pe = &(*events)[slot]; - *pe = *e; - - sqe = ctl->sqe; - sqe = &sqe[slot]; - - memset(sqe, 0, sizeof(*sqe)); - sqe->addr = (uintptr_t) pe; - sqe->fd = epollfd; - sqe->len = op; - sqe->off = fd; - sqe->opcode = UV__IORING_OP_EPOLL_CTL; - sqe->user_data = op | slot << 2 | (int64_t) fd << 32; - - if ((*ctl->sqhead & mask) == (*ctl->sqtail & mask)) - uv__epoll_ctl_flush(epollfd, ctl, events); - } -} - - -static void uv__epoll_ctl_flush(int epollfd, - struct uv__iou* ctl, - struct epoll_event (*events)[256]) { - struct epoll_event oldevents[256]; - struct uv__io_uring_cqe* cqe; - uint32_t oldslot; - uint32_t slot; - uint32_t n; - int fd; - int op; - int rc; - - STATIC_ASSERT(sizeof(oldevents) == sizeof(*events)); - assert(ctl->ringfd != -1); - assert(*ctl->sqhead != *ctl->sqtail); - - n = *ctl->sqtail - *ctl->sqhead; - do - rc = uv__io_uring_enter(ctl->ringfd, n, n, UV__IORING_ENTER_GETEVENTS); - while (rc == -1 && errno == EINTR); - - if (rc < 0) - perror("libuv: io_uring_enter(getevents)"); /* Can't happen. */ - - if (rc != (int) n) - abort(); - - assert(*ctl->sqhead == *ctl->sqtail); - - memcpy(oldevents, *events, sizeof(*events)); - - /* Failed submissions are either EPOLL_CTL_DEL commands for file descriptors - * that have been closed, or EPOLL_CTL_ADD commands for file descriptors - * that we are already watching. Ignore the former and retry the latter - * with EPOLL_CTL_MOD. - */ - while (*ctl->cqhead != *ctl->cqtail) { - slot = (*ctl->cqhead)++ & ctl->cqmask; - - cqe = ctl->cqe; - cqe = &cqe[slot]; - - if (cqe->res == 0) - continue; - - fd = cqe->user_data >> 32; - op = 3 & cqe->user_data; - oldslot = 255 & (cqe->user_data >> 2); - - if (op == EPOLL_CTL_DEL) - continue; - - if (op != EPOLL_CTL_ADD) - abort(); - - if (cqe->res != -EEXIST) - abort(); - - uv__epoll_ctl_prep(epollfd, - ctl, - events, - EPOLL_CTL_MOD, - fd, - &oldevents[oldslot]); - } -} - - -void uv__io_poll(uv_loop_t* loop, int timeout) { - uv__loop_internal_fields_t* lfields; - struct epoll_event events[1024]; - struct epoll_event prep[256]; - struct uv__invalidate inv; - struct epoll_event* pe; - struct epoll_event e; - struct uv__iou* ctl; - struct uv__iou* iou; - int real_timeout; - struct uv__queue* q; - uv__io_t* w; - sigset_t* sigmask; - sigset_t sigset; - uint64_t base; - int have_iou_events; - int have_signals; - int nevents; - int epollfd; - int count; - int nfds; - int fd; - int op; - int i; - int user_timeout; - int reset_timeout; - - lfields = uv__get_internal_fields(loop); - ctl = &lfields->ctl; - iou = &lfields->iou; - - sigmask = NULL; - if (loop->flags & UV_LOOP_BLOCK_SIGPROF) { - sigemptyset(&sigset); - sigaddset(&sigset, SIGPROF); - sigmask = &sigset; - } - - assert(timeout >= -1); - base = loop->time; - count = 48; /* Benchmarks suggest this gives the best throughput. */ - real_timeout = timeout; - - if (lfields->flags & UV_METRICS_IDLE_TIME) { - reset_timeout = 1; - user_timeout = timeout; - timeout = 0; - } else { - reset_timeout = 0; - user_timeout = 0; - } - - epollfd = loop->backend_fd; - - memset(&e, 0, sizeof(e)); - - while (!uv__queue_empty(&loop->watcher_queue)) { - q = uv__queue_head(&loop->watcher_queue); - w = uv__queue_data(q, uv__io_t, watcher_queue); - uv__queue_remove(q); - uv__queue_init(q); - - op = EPOLL_CTL_MOD; - if (w->events == 0) - op = EPOLL_CTL_ADD; - - w->events = w->pevents; - e.events = w->pevents; - e.data.fd = w->fd; - - uv__epoll_ctl_prep(epollfd, ctl, &prep, op, w->fd, &e); - } - - inv.events = events; - inv.prep = &prep; - inv.nfds = -1; - - for (;;) { - if (loop->nfds == 0) - if (iou->in_flight == 0) - break; - - /* All event mask mutations should be visible to the kernel before - * we enter epoll_pwait(). - */ - if (ctl->ringfd != -1) - while (*ctl->sqhead != *ctl->sqtail) - uv__epoll_ctl_flush(epollfd, ctl, &prep); - - /* Only need to set the provider_entry_time if timeout != 0. The function - * will return early if the loop isn't configured with UV_METRICS_IDLE_TIME. - */ - if (timeout != 0) - uv__metrics_set_provider_entry_time(loop); - - /* Store the current timeout in a location that's globally accessible so - * other locations like uv__work_done() can determine whether the queue - * of events in the callback were waiting when poll was called. - */ - lfields->current_timeout = timeout; -#ifdef USE_FFRT - if (ffrt_get_cur_task() == NULL) { - nfds = epoll_pwait(epollfd, events, ARRAY_SIZE(events), timeout, sigmask); - } else { - nfds = uv__epoll_wait(events, ARRAY_SIZE(events), timeout); - } -#else - nfds = epoll_pwait(epollfd, events, ARRAY_SIZE(events), timeout, sigmask); -#endif - - /* Update loop->time unconditionally. It's tempting to skip the update when - * timeout == 0 (i.e. non-blocking poll) but there is no guarantee that the - * operating system didn't reschedule our process while in the syscall. - */ - SAVE_ERRNO(uv__update_time(loop)); - - if (nfds == -1) - assert(errno == EINTR); - else if (nfds == 0) - /* Unlimited timeout should only return with events or signal. */ - assert(timeout != -1); - - if (nfds == 0 || nfds == -1) { - if (reset_timeout != 0) { - timeout = user_timeout; - reset_timeout = 0; - } else if (nfds == 0) { - return; - } - - /* Interrupted by a signal. Update timeout and poll again. */ - goto update_timeout; - } - - have_iou_events = 0; - have_signals = 0; - nevents = 0; - - inv.nfds = nfds; - lfields->inv = &inv; - - for (i = 0; i < nfds; i++) { - pe = events + i; - fd = pe->data.fd; - - /* Skip invalidated events, see uv__platform_invalidate_fd */ - if (fd == -1) - continue; - - if (fd == iou->ringfd) { - uv__poll_io_uring(loop, iou); - have_iou_events = 1; - continue; - } - - assert(fd >= 0); - assert((unsigned) fd < loop->nwatchers); - - w = loop->watchers[fd]; - - if (w == NULL) { - /* File descriptor that we've stopped watching, disarm it. - * - * Ignore all errors because we may be racing with another thread - * when the file descriptor is closed. - */ - uv__epoll_ctl_prep(epollfd, ctl, &prep, EPOLL_CTL_DEL, fd, pe); - continue; - } - - /* Give users only events they're interested in. Prevents spurious - * callbacks when previous callback invocation in this loop has stopped - * the current watcher. Also, filters out events that users has not - * requested us to watch. - */ - pe->events &= w->pevents | POLLERR | POLLHUP; - - /* Work around an epoll quirk where it sometimes reports just the - * EPOLLERR or EPOLLHUP event. In order to force the event loop to - * move forward, we merge in the read/write events that the watcher - * is interested in; uv__read() and uv__write() will then deal with - * the error or hangup in the usual fashion. - * - * Note to self: happens when epoll reports EPOLLIN|EPOLLHUP, the user - * reads the available data, calls uv_read_stop(), then sometime later - * calls uv_read_start() again. By then, libuv has forgotten about the - * hangup and the kernel won't report EPOLLIN again because there's - * nothing left to read. If anything, libuv is to blame here. The - * current hack is just a quick bandaid; to properly fix it, libuv - * needs to remember the error/hangup event. We should get that for - * free when we switch over to edge-triggered I/O. - */ - if (pe->events == POLLERR || pe->events == POLLHUP) - pe->events |= - w->pevents & (POLLIN | POLLOUT | UV__POLLRDHUP | UV__POLLPRI); - - if (pe->events != 0) { - /* Run signal watchers last. This also affects child process watchers - * because those are implemented in terms of signal watchers. - */ - if (w == &loop->signal_io_watcher) { - have_signals = 1; - } else { - uv__metrics_update_idle_time(loop); - w->cb(loop, w, pe->events); - } - - nevents++; - } - } - - uv__metrics_inc_events(loop, nevents); - if (reset_timeout != 0) { - timeout = user_timeout; - reset_timeout = 0; - uv__metrics_inc_events_waiting(loop, nevents); - } - - if (have_signals != 0) { - uv__metrics_update_idle_time(loop); - loop->signal_io_watcher.cb(loop, &loop->signal_io_watcher, POLLIN); - } - - lfields->inv = NULL; - - if (have_iou_events != 0) - break; /* Event loop should cycle now so don't poll again. */ - - if (have_signals != 0) - break; /* Event loop should cycle now so don't poll again. */ - - if (nevents != 0) { - if (nfds == ARRAY_SIZE(events) && --count != 0) { - /* Poll for more events but don't block this time. */ - timeout = 0; - continue; - } - break; - } - -update_timeout: - if (timeout == 0) - break; - - if (timeout == -1) - continue; - - assert(timeout > 0); - - real_timeout -= (loop->time - base); - if (real_timeout <= 0) - break; - - timeout = real_timeout; - } - - if (ctl->ringfd != -1) - while (*ctl->sqhead != *ctl->sqtail) - uv__epoll_ctl_flush(epollfd, ctl, &prep); -} - -uint64_t uv__hrtime(uv_clocktype_t type) { - static _Atomic clock_t fast_clock_id = -1; - struct timespec t; - clock_t clock_id; - - /* Prefer CLOCK_MONOTONIC_COARSE if available but only when it has - * millisecond granularity or better. CLOCK_MONOTONIC_COARSE is - * serviced entirely from the vDSO, whereas CLOCK_MONOTONIC may - * decide to make a costly system call. - */ - /* TODO(bnoordhuis) Use CLOCK_MONOTONIC_COARSE for UV_CLOCK_PRECISE - * when it has microsecond granularity or better (unlikely). - */ - clock_id = CLOCK_MONOTONIC; - if (type != UV_CLOCK_FAST) - goto done; - - clock_id = atomic_load_explicit(&fast_clock_id, memory_order_relaxed); - if (clock_id != -1) - goto done; - - clock_id = CLOCK_MONOTONIC; - if (0 == clock_getres(CLOCK_MONOTONIC_COARSE, &t)) - if (t.tv_nsec <= 1 * 1000 * 1000) - clock_id = CLOCK_MONOTONIC_COARSE; - - atomic_store_explicit(&fast_clock_id, clock_id, memory_order_relaxed); - -done: - - if (clock_gettime(clock_id, &t)) - return 0; /* Not really possible. */ - - return t.tv_sec * (uint64_t) 1e9 + t.tv_nsec; -} - - -int uv_resident_set_memory(size_t* rss) { - char buf[1024]; - const char* s; - ssize_t n; - long val; - int fd; - int i; - - do - fd = open("/proc/self/stat", O_RDONLY); - while (fd == -1 && errno == EINTR); - - if (fd == -1) - return UV__ERR(errno); - - do - n = read(fd, buf, sizeof(buf) - 1); - while (n == -1 && errno == EINTR); - - uv__close(fd); - if (n == -1) - return UV__ERR(errno); - buf[n] = '\0'; - - s = strchr(buf, ' '); - if (s == NULL) - goto err; - - s += 1; - if (*s != '(') - goto err; - - s = strchr(s, ')'); - if (s == NULL) - goto err; - - for (i = 1; i <= 22; i++) { - s = strchr(s + 1, ' '); - if (s == NULL) - goto err; - } - - errno = 0; - val = strtol(s, NULL, 10); - if (errno != 0) - goto err; - if (val < 0) - goto err; - - *rss = val * getpagesize(); - return 0; - -err: - return UV_EINVAL; -} - -int uv_uptime(double* uptime) { - struct timespec now; - char buf[128]; - - /* Consult /proc/uptime when present (common case), or fall back to - * clock_gettime. Why not always clock_gettime? It doesn't always return the - * right result under OpenVZ and possibly other containerized environments. - */ - if (0 == uv__slurp("/proc/uptime", buf, sizeof(buf))) - if (1 == sscanf(buf, "%lf", uptime)) - return 0; - - if (clock_gettime(CLOCK_BOOTTIME, &now)) - return UV__ERR(errno); - - *uptime = now.tv_sec; - return 0; -} - - -int uv_cpu_info(uv_cpu_info_t** ci, int* count) { -#if defined(__PPC__) - static const char model_marker[] = "cpu\t\t: "; -#elif defined(__arm__) - static const char model_marker[] = "Processor\t: "; -#elif defined(__aarch64__) - static const char model_marker[] = "CPU part\t: "; -#elif defined(__mips__) - static const char model_marker[] = "cpu model\t\t: "; -#elif defined(__loongarch__) - static const char model_marker[] = "cpu family\t\t: "; -#else - static const char model_marker[] = "model name\t: "; -#endif - static const char parts[] = -#ifdef __aarch64__ - "0x811\nARM810\n" "0x920\nARM920\n" "0x922\nARM922\n" - "0x926\nARM926\n" "0x940\nARM940\n" "0x946\nARM946\n" - "0x966\nARM966\n" "0xa20\nARM1020\n" "0xa22\nARM1022\n" - "0xa26\nARM1026\n" "0xb02\nARM11 MPCore\n" "0xb36\nARM1136\n" - "0xb56\nARM1156\n" "0xb76\nARM1176\n" "0xc05\nCortex-A5\n" - "0xc07\nCortex-A7\n" "0xc08\nCortex-A8\n" "0xc09\nCortex-A9\n" - "0xc0d\nCortex-A17\n" /* Originally A12 */ - "0xc0f\nCortex-A15\n" "0xc0e\nCortex-A17\n" "0xc14\nCortex-R4\n" - "0xc15\nCortex-R5\n" "0xc17\nCortex-R7\n" "0xc18\nCortex-R8\n" - "0xc20\nCortex-M0\n" "0xc21\nCortex-M1\n" "0xc23\nCortex-M3\n" - "0xc24\nCortex-M4\n" "0xc27\nCortex-M7\n" "0xc60\nCortex-M0+\n" - "0xd01\nCortex-A32\n" "0xd03\nCortex-A53\n" "0xd04\nCortex-A35\n" - "0xd05\nCortex-A55\n" "0xd06\nCortex-A65\n" "0xd07\nCortex-A57\n" - "0xd08\nCortex-A72\n" "0xd09\nCortex-A73\n" "0xd0a\nCortex-A75\n" - "0xd0b\nCortex-A76\n" "0xd0c\nNeoverse-N1\n" "0xd0d\nCortex-A77\n" - "0xd0e\nCortex-A76AE\n" "0xd13\nCortex-R52\n" "0xd20\nCortex-M23\n" - "0xd21\nCortex-M33\n" "0xd41\nCortex-A78\n" "0xd42\nCortex-A78AE\n" - "0xd4a\nNeoverse-E1\n" "0xd4b\nCortex-A78C\n" -#endif - ""; - struct cpu { - unsigned long long freq, user, nice, sys, idle, irq; - unsigned model; - }; - FILE* fp; - char* p; - int found; - int n; - unsigned i; - unsigned cpu; - unsigned maxcpu; - unsigned size; - unsigned long long skip; - struct cpu (*cpus)[8192]; /* Kernel maximum. */ - struct cpu* c; - struct cpu t; - char (*model)[64]; - unsigned char bitmap[ARRAY_SIZE(*cpus) / 8]; - /* Assumption: even big.LITTLE systems will have only a handful - * of different CPU models. Most systems will just have one. - */ - char models[8][64]; - char buf[1024]; - - memset(bitmap, 0, sizeof(bitmap)); - memset(models, 0, sizeof(models)); - snprintf(*models, sizeof(*models), "unknown"); - maxcpu = 0; - - cpus = uv__calloc(ARRAY_SIZE(*cpus), sizeof(**cpus)); - if (cpus == NULL) - return UV_ENOMEM; - - fp = uv__open_file("/proc/stat"); - if (fp == NULL) { - uv__free(cpus); - return UV__ERR(errno); - } - - if (NULL == fgets(buf, sizeof(buf), fp)) - abort(); - - for (;;) { - memset(&t, 0, sizeof(t)); - - n = fscanf(fp, "cpu%u %llu %llu %llu %llu %llu %llu", - &cpu, &t.user, &t.nice, &t.sys, &t.idle, &skip, &t.irq); - - if (n != 7) - break; - - if (NULL == fgets(buf, sizeof(buf), fp)) - abort(); - - if (cpu >= ARRAY_SIZE(*cpus)) - continue; - - (*cpus)[cpu] = t; - - bitmap[cpu >> 3] |= 1 << (cpu & 7); - - if (cpu >= maxcpu) - maxcpu = cpu + 1; - } - - fclose(fp); - - fp = uv__open_file("/proc/cpuinfo"); - if (fp == NULL) - goto nocpuinfo; - - for (;;) { - if (1 != fscanf(fp, "processor\t: %u\n", &cpu)) - break; /* Parse error. */ - - found = 0; - while (!found && fgets(buf, sizeof(buf), fp)) - found = !strncmp(buf, model_marker, sizeof(model_marker) - 1); - - if (!found) - goto next; - - p = buf + sizeof(model_marker) - 1; - n = (int) strcspn(p, "\n"); - - /* arm64: translate CPU part code to model name. */ - if (*parts) { - p = memmem(parts, sizeof(parts) - 1, p, n + 1); - if (p == NULL) - p = "unknown"; - else - p += n + 1; - n = (int) strcspn(p, "\n"); - } - - found = 0; - for (model = models; !found && model < ARRAY_END(models); model++) - found = !strncmp(p, *model, strlen(*model)); - - if (!found) - goto next; - - if (**model == '\0') - snprintf(*model, sizeof(*model), "%.*s", n, p); - - if (cpu < maxcpu) - (*cpus)[cpu].model = model - models; - -next: - while (fgets(buf, sizeof(buf), fp)) - if (*buf == '\n') - break; - } - - fclose(fp); - fp = NULL; - -nocpuinfo: - - n = 0; - for (cpu = 0; cpu < maxcpu; cpu++) { - if (!(bitmap[cpu >> 3] & (1 << (cpu & 7)))) - continue; - - n++; - snprintf(buf, sizeof(buf), - "/sys/devices/system/cpu/cpu%u/cpufreq/scaling_cur_freq", cpu); - - fp = uv__open_file(buf); - if (fp == NULL) - continue; - - if (1 != fscanf(fp, "%llu", &(*cpus)[cpu].freq)) - abort(); - fclose(fp); - fp = NULL; - } - - size = n * sizeof(**ci) + sizeof(models); - *ci = uv__malloc(size); - *count = 0; - - if (*ci == NULL) { - uv__free(cpus); - return UV_ENOMEM; - } - - *count = n; - p = memcpy(*ci + n, models, sizeof(models)); - - i = 0; - for (cpu = 0; cpu < maxcpu; cpu++) { - if (!(bitmap[cpu >> 3] & (1 << (cpu & 7)))) - continue; - - c = *cpus + cpu; - - (*ci)[i++] = (uv_cpu_info_t) { - .model = p + c->model * sizeof(*model), - .speed = c->freq / 1000, - /* Note: sysconf(_SC_CLK_TCK) is fixed at 100 Hz, - * therefore the multiplier is always 1000/100 = 10. - */ - .cpu_times = (struct uv_cpu_times_s) { - .user = 10 * c->user, - .nice = 10 * c->nice, - .sys = 10 * c->sys, - .idle = 10 * c->idle, - .irq = 10 * c->irq, - }, - }; - } - - uv__free(cpus); - - return 0; -} - - -static int uv__ifaddr_exclude(struct ifaddrs *ent, int exclude_type) { - if (!((ent->ifa_flags & IFF_UP) && (ent->ifa_flags & IFF_RUNNING))) - return 1; - if (ent->ifa_addr == NULL) - return 1; - /* - * On Linux getifaddrs returns information related to the raw underlying - * devices. We're not interested in this information yet. - */ - if (ent->ifa_addr->sa_family == PF_PACKET) - return exclude_type; - return !exclude_type; -} - -int uv_interface_addresses(uv_interface_address_t** addresses, int* count) { - struct ifaddrs *addrs, *ent; - uv_interface_address_t* address; - int i; - struct sockaddr_ll *sll; - - *count = 0; - *addresses = NULL; - - if (getifaddrs(&addrs)) - return UV__ERR(errno); - - /* Count the number of interfaces */ - for (ent = addrs; ent != NULL; ent = ent->ifa_next) { - if (uv__ifaddr_exclude(ent, UV__EXCLUDE_IFADDR)) - continue; - - (*count)++; - } - - if (*count == 0) { - freeifaddrs(addrs); - return 0; - } - - /* Make sure the memory is initiallized to zero using calloc() */ - *addresses = uv__calloc(*count, sizeof(**addresses)); - if (!(*addresses)) { - freeifaddrs(addrs); - return UV_ENOMEM; - } - - address = *addresses; - - for (ent = addrs; ent != NULL; ent = ent->ifa_next) { - if (uv__ifaddr_exclude(ent, UV__EXCLUDE_IFADDR)) - continue; - - address->name = uv__strdup(ent->ifa_name); - - if (ent->ifa_addr->sa_family == AF_INET6) { - address->address.address6 = *((struct sockaddr_in6*) ent->ifa_addr); - } else { - address->address.address4 = *((struct sockaddr_in*) ent->ifa_addr); - } - - if (ent->ifa_netmask->sa_family == AF_INET6) { - address->netmask.netmask6 = *((struct sockaddr_in6*) ent->ifa_netmask); - } else { - address->netmask.netmask4 = *((struct sockaddr_in*) ent->ifa_netmask); - } - - address->is_internal = !!(ent->ifa_flags & IFF_LOOPBACK); - - address++; - } - - /* Fill in physical addresses for each interface */ - for (ent = addrs; ent != NULL; ent = ent->ifa_next) { - if (uv__ifaddr_exclude(ent, UV__EXCLUDE_IFPHYS)) - continue; - - address = *addresses; - - for (i = 0; i < (*count); i++) { - size_t namelen = strlen(ent->ifa_name); - /* Alias interface share the same physical address */ - if (strncmp(address->name, ent->ifa_name, namelen) == 0 && - (address->name[namelen] == 0 || address->name[namelen] == ':')) { - sll = (struct sockaddr_ll*)ent->ifa_addr; - memcpy(address->phys_addr, sll->sll_addr, sizeof(address->phys_addr)); - } - address++; - } - } - - freeifaddrs(addrs); - - return 0; -} - - -void uv_free_interface_addresses(uv_interface_address_t* addresses, - int count) { - int i; - - for (i = 0; i < count; i++) { - uv__free(addresses[i].name); - } - - uv__free(addresses); -} - - -void uv__set_process_title(const char* title) { -#if defined(PR_SET_NAME) - prctl(PR_SET_NAME, title); /* Only copies first 16 characters. */ -#endif -} - - -static uint64_t uv__read_proc_meminfo(const char* what) { - uint64_t rc; - char* p; - char buf[4096]; /* Large enough to hold all of /proc/meminfo. */ - - if (uv__slurp("/proc/meminfo", buf, sizeof(buf))) - return 0; - - p = strstr(buf, what); - - if (p == NULL) - return 0; - - p += strlen(what); - - rc = 0; - sscanf(p, "%" PRIu64 " kB", &rc); - - return rc * 1024; -} - - -uint64_t uv_get_free_memory(void) { - struct sysinfo info; - uint64_t rc; - - rc = uv__read_proc_meminfo("MemAvailable:"); - - if (rc != 0) - return rc; - - if (0 == sysinfo(&info)) - return (uint64_t) info.freeram * info.mem_unit; - - return 0; -} - - -uint64_t uv_get_total_memory(void) { - struct sysinfo info; - uint64_t rc; - - rc = uv__read_proc_meminfo("MemTotal:"); - - if (rc != 0) - return rc; - - if (0 == sysinfo(&info)) - return (uint64_t) info.totalram * info.mem_unit; - - return 0; -} - - -static uint64_t uv__read_uint64(const char* filename) { - char buf[32]; /* Large enough to hold an encoded uint64_t. */ - uint64_t rc; - - rc = 0; - if (0 == uv__slurp(filename, buf, sizeof(buf))) - if (1 != sscanf(buf, "%" PRIu64, &rc)) - if (0 == strcmp(buf, "max\n")) - rc = UINT64_MAX; - - return rc; -} - - -/* Given a buffer with the contents of a cgroup1 /proc/self/cgroups, - * finds the location and length of the memory controller mount path. - * This disregards the leading / for easy concatenation of paths. - * Returns NULL if the memory controller wasn't found. */ -static char* uv__cgroup1_find_memory_controller(char buf[static 1024], - int* n) { - char* p; - - /* Seek to the memory controller line. */ - p = strchr(buf, ':'); - while (p != NULL && strncmp(p, ":memory:", 8)) { - p = strchr(p, '\n'); - if (p != NULL) - p = strchr(p, ':'); - } - - if (p != NULL) { - /* Determine the length of the mount path. */ - p = p + strlen(":memory:/"); - *n = (int) strcspn(p, "\n"); - } - - return p; -} - -static void uv__get_cgroup1_memory_limits(char buf[static 1024], uint64_t* high, - uint64_t* max) { - char filename[4097]; - char* p; - int n; - uint64_t cgroup1_max; - - /* Find out where the controller is mounted. */ - p = uv__cgroup1_find_memory_controller(buf, &n); - if (p != NULL) { - snprintf(filename, sizeof(filename), - "/sys/fs/cgroup/memory/%.*s/memory.soft_limit_in_bytes", n, p); - *high = uv__read_uint64(filename); - - snprintf(filename, sizeof(filename), - "/sys/fs/cgroup/memory/%.*s/memory.limit_in_bytes", n, p); - *max = uv__read_uint64(filename); - - /* If the controller wasn't mounted, the reads above will have failed, - * as indicated by uv__read_uint64 returning 0. - */ - if (*high != 0 && *max != 0) - goto update_limits; - } - - /* Fall back to the limits of the global memory controller. */ - *high = uv__read_uint64("/sys/fs/cgroup/memory/memory.soft_limit_in_bytes"); - *max = uv__read_uint64("/sys/fs/cgroup/memory/memory.limit_in_bytes"); - - /* uv__read_uint64 detects cgroup2's "max", so we need to separately detect - * cgroup1's maximum value (which is derived from LONG_MAX and PAGE_SIZE). - */ -update_limits: - cgroup1_max = LONG_MAX & ~(sysconf(_SC_PAGESIZE) - 1); - if (*high == cgroup1_max) - *high = UINT64_MAX; - if (*max == cgroup1_max) - *max = UINT64_MAX; -} - -static void uv__get_cgroup2_memory_limits(char buf[static 1024], uint64_t* high, - uint64_t* max) { - char filename[4097]; - char* p; - int n; - - /* Find out where the controller is mounted. */ - p = buf + strlen("0::/"); - n = (int) strcspn(p, "\n"); - - /* Read the memory limits of the controller. */ - snprintf(filename, sizeof(filename), "/sys/fs/cgroup/%.*s/memory.max", n, p); - *max = uv__read_uint64(filename); - snprintf(filename, sizeof(filename), "/sys/fs/cgroup/%.*s/memory.high", n, p); - *high = uv__read_uint64(filename); -} - -static uint64_t uv__get_cgroup_constrained_memory(char buf[static 1024]) { - uint64_t high; - uint64_t max; - - /* In the case of cgroupv2, we'll only have a single entry. */ - if (strncmp(buf, "0::/", 4)) - uv__get_cgroup1_memory_limits(buf, &high, &max); - else - uv__get_cgroup2_memory_limits(buf, &high, &max); - - if (high == 0 || max == 0) - return 0; - - return high < max ? high : max; -} - -uint64_t uv_get_constrained_memory(void) { - char buf[1024]; - - if (uv__slurp("/proc/self/cgroup", buf, sizeof(buf))) - return 0; - - return uv__get_cgroup_constrained_memory(buf); -} - - -static uint64_t uv__get_cgroup1_current_memory(char buf[static 1024]) { - char filename[4097]; - uint64_t current; - char* p; - int n; - - /* Find out where the controller is mounted. */ - p = uv__cgroup1_find_memory_controller(buf, &n); - if (p != NULL) { - snprintf(filename, sizeof(filename), - "/sys/fs/cgroup/memory/%.*s/memory.usage_in_bytes", n, p); - current = uv__read_uint64(filename); - - /* If the controller wasn't mounted, the reads above will have failed, - * as indicated by uv__read_uint64 returning 0. - */ - if (current != 0) - return current; - } - - /* Fall back to the usage of the global memory controller. */ - return uv__read_uint64("/sys/fs/cgroup/memory/memory.usage_in_bytes"); -} - -static uint64_t uv__get_cgroup2_current_memory(char buf[static 1024]) { - char filename[4097]; - char* p; - int n; - - /* Find out where the controller is mounted. */ - p = buf + strlen("0::/"); - n = (int) strcspn(p, "\n"); - - snprintf(filename, sizeof(filename), - "/sys/fs/cgroup/%.*s/memory.current", n, p); - return uv__read_uint64(filename); -} - -uint64_t uv_get_available_memory(void) { - char buf[1024]; - uint64_t constrained; - uint64_t current; - uint64_t total; - - if (uv__slurp("/proc/self/cgroup", buf, sizeof(buf))) - return 0; - - constrained = uv__get_cgroup_constrained_memory(buf); - if (constrained == 0) - return uv_get_free_memory(); - - total = uv_get_total_memory(); - if (constrained > total) - return uv_get_free_memory(); - - /* In the case of cgroupv2, we'll only have a single entry. */ - if (strncmp(buf, "0::/", 4)) - current = uv__get_cgroup1_current_memory(buf); - else - current = uv__get_cgroup2_current_memory(buf); - - /* memory usage can be higher than the limit (for short bursts of time) */ - if (constrained < current) - return 0; - - return constrained - current; -} - - -void uv_loadavg(double avg[3]) { - struct sysinfo info; - char buf[128]; /* Large enough to hold all of /proc/loadavg. */ - - if (0 == uv__slurp("/proc/loadavg", buf, sizeof(buf))) - if (3 == sscanf(buf, "%lf %lf %lf", &avg[0], &avg[1], &avg[2])) - return; - - if (sysinfo(&info) < 0) - return; - - avg[0] = (double) info.loads[0] / 65536.0; - avg[1] = (double) info.loads[1] / 65536.0; - avg[2] = (double) info.loads[2] / 65536.0; -} - - -static int compare_watchers(const struct watcher_list* a, - const struct watcher_list* b) { - if (a->wd < b->wd) return -1; - if (a->wd > b->wd) return 1; - return 0; -} - - -static int init_inotify(uv_loop_t* loop) { - int fd; - - if (loop->inotify_fd != -1) - return 0; - - fd = inotify_init1(IN_NONBLOCK | IN_CLOEXEC); - if (fd < 0) - return UV__ERR(errno); - - loop->inotify_fd = fd; - uv__io_init(&loop->inotify_read_watcher, uv__inotify_read, loop->inotify_fd); - uv__io_start(loop, &loop->inotify_read_watcher, POLLIN); - - return 0; -} - - -static int uv__inotify_fork(uv_loop_t* loop, struct watcher_list* root) { - /* Open the inotify_fd, and re-arm all the inotify watchers. */ - int err; - struct watcher_list* tmp_watcher_list_iter; - struct watcher_list* watcher_list; - struct watcher_list tmp_watcher_list; - struct uv__queue queue; - struct uv__queue* q; - uv_fs_event_t* handle; - char* tmp_path; - - if (root == NULL) - return 0; - - /* We must restore the old watcher list to be able to close items - * out of it. - */ - loop->inotify_watchers = root; - - uv__queue_init(&tmp_watcher_list.watchers); - /* Note that the queue we use is shared with the start and stop() - * functions, making uv__queue_foreach unsafe to use. So we use the - * uv__queue_move trick to safely iterate. Also don't free the watcher - * list until we're done iterating. c.f. uv__inotify_read. - */ - RB_FOREACH_SAFE(watcher_list, watcher_root, - uv__inotify_watchers(loop), tmp_watcher_list_iter) { - watcher_list->iterating = 1; - uv__queue_move(&watcher_list->watchers, &queue); - while (!uv__queue_empty(&queue)) { - q = uv__queue_head(&queue); - handle = uv__queue_data(q, uv_fs_event_t, watchers); - /* It's critical to keep a copy of path here, because it - * will be set to NULL by stop() and then deallocated by - * maybe_free_watcher_list - */ - tmp_path = uv__strdup(handle->path); - assert(tmp_path != NULL); - uv__queue_remove(q); - uv__queue_insert_tail(&watcher_list->watchers, q); - uv_fs_event_stop(handle); - - uv__queue_insert_tail(&tmp_watcher_list.watchers, &handle->watchers); - handle->path = tmp_path; - } - watcher_list->iterating = 0; - maybe_free_watcher_list(watcher_list, loop); - } - - uv__queue_move(&tmp_watcher_list.watchers, &queue); - while (!uv__queue_empty(&queue)) { - q = uv__queue_head(&queue); - uv__queue_remove(q); - handle = uv__queue_data(q, uv_fs_event_t, watchers); - tmp_path = handle->path; - handle->path = NULL; - err = uv_fs_event_start(handle, handle->cb, tmp_path, 0); - uv__free(tmp_path); - if (err) - return err; - } - - return 0; -} - - -static struct watcher_list* find_watcher(uv_loop_t* loop, int wd) { - struct watcher_list w; - w.wd = wd; - return RB_FIND(watcher_root, uv__inotify_watchers(loop), &w); -} - - -static void maybe_free_watcher_list(struct watcher_list* w, uv_loop_t* loop) { - /* if the watcher_list->watchers is being iterated over, we can't free it. */ - if ((!w->iterating) && uv__queue_empty(&w->watchers)) { - /* No watchers left for this path. Clean up. */ - RB_REMOVE(watcher_root, uv__inotify_watchers(loop), w); - inotify_rm_watch(loop->inotify_fd, w->wd); - uv__free(w); - } -} - - -static void uv__inotify_read(uv_loop_t* loop, - uv__io_t* dummy, - unsigned int events) { - const struct inotify_event* e; - struct watcher_list* w; - uv_fs_event_t* h; - struct uv__queue queue; - struct uv__queue* q; - const char* path; - ssize_t size; - const char *p; - /* needs to be large enough for sizeof(inotify_event) + strlen(path) */ - char buf[4096]; - - for (;;) { - do - size = read(loop->inotify_fd, buf, sizeof(buf)); - while (size == -1 && errno == EINTR); - - if (size == -1) { - assert(errno == EAGAIN || errno == EWOULDBLOCK); - break; - } - - assert(size > 0); /* pre-2.6.21 thing, size=0 == read buffer too small */ - - /* Now we have one or more inotify_event structs. */ - for (p = buf; p < buf + size; p += sizeof(*e) + e->len) { - e = (const struct inotify_event*) p; - - events = 0; - if (e->mask & (IN_ATTRIB|IN_MODIFY)) - events |= UV_CHANGE; - if (e->mask & ~(IN_ATTRIB|IN_MODIFY)) - events |= UV_RENAME; - - w = find_watcher(loop, e->wd); - if (w == NULL) - continue; /* Stale event, no watchers left. */ - - /* inotify does not return the filename when monitoring a single file - * for modifications. Repurpose the filename for API compatibility. - * I'm not convinced this is a good thing, maybe it should go. - */ - path = e->len ? (const char*) (e + 1) : uv__basename_r(w->path); - - /* We're about to iterate over the queue and call user's callbacks. - * What can go wrong? - * A callback could call uv_fs_event_stop() - * and the queue can change under our feet. - * So, we use uv__queue_move() trick to safely iterate over the queue. - * And we don't free the watcher_list until we're done iterating. - * - * First, - * tell uv_fs_event_stop() (that could be called from a user's callback) - * not to free watcher_list. - */ - w->iterating = 1; - uv__queue_move(&w->watchers, &queue); - while (!uv__queue_empty(&queue)) { - q = uv__queue_head(&queue); - h = uv__queue_data(q, uv_fs_event_t, watchers); - - uv__queue_remove(q); - uv__queue_insert_tail(&w->watchers, q); - - h->cb(h, path, events, 0); - } - /* done iterating, time to (maybe) free empty watcher_list */ - w->iterating = 0; - maybe_free_watcher_list(w, loop); - } - } -} - - -int uv_fs_event_init(uv_loop_t* loop, uv_fs_event_t* handle) { - uv__handle_init(loop, (uv_handle_t*)handle, UV_FS_EVENT); - return 0; -} - - -int uv_fs_event_start(uv_fs_event_t* handle, - uv_fs_event_cb cb, - const char* path, - unsigned int flags) { - struct watcher_list* w; - uv_loop_t* loop; - size_t len; - int events; - int err; - int wd; - - if (uv__is_active(handle)) - return UV_EINVAL; - - loop = handle->loop; - - err = init_inotify(loop); - if (err) - return err; - - events = IN_ATTRIB - | IN_CREATE - | IN_MODIFY - | IN_DELETE - | IN_DELETE_SELF - | IN_MOVE_SELF - | IN_MOVED_FROM - | IN_MOVED_TO; - - wd = inotify_add_watch(loop->inotify_fd, path, events); - if (wd == -1) - return UV__ERR(errno); - - w = find_watcher(loop, wd); - if (w) - goto no_insert; - - len = strlen(path) + 1; - w = uv__malloc(sizeof(*w) + len); - if (w == NULL) - return UV_ENOMEM; - - w->wd = wd; - w->path = memcpy(w + 1, path, len); - uv__queue_init(&w->watchers); - w->iterating = 0; - RB_INSERT(watcher_root, uv__inotify_watchers(loop), w); - -no_insert: - uv__handle_start(handle); - uv__queue_insert_tail(&w->watchers, &handle->watchers); - handle->path = w->path; - handle->cb = cb; - handle->wd = wd; - - return 0; -} - - -int uv_fs_event_stop(uv_fs_event_t* handle) { - struct watcher_list* w; - - if (!uv__is_active(handle)) - return 0; - - w = find_watcher(handle->loop, handle->wd); - assert(w != NULL); - - handle->wd = -1; - handle->path = NULL; - uv__handle_stop(handle); - uv__queue_remove(&handle->watchers); - - maybe_free_watcher_list(w, handle->loop); - - return 0; -} - - -void uv__fs_event_close(uv_fs_event_t* handle) { - uv_fs_event_stop(handle); -} diff --git a/src/unix/loop-watcher.c b/src/unix/loop-watcher.c index 2db8b51..b8c1c2a 100644 --- a/src/unix/loop-watcher.c +++ b/src/unix/loop-watcher.c @@ -32,7 +32,7 @@ int uv_##name##_start(uv_##name##_t* handle, uv_##name##_cb cb) { \ if (uv__is_active(handle)) return 0; \ if (cb == NULL) return UV_EINVAL; \ - uv__queue_insert_head(&handle->loop->name##_handles, &handle->queue); \ + QUEUE_INSERT_HEAD(&handle->loop->name##_handles, &handle->queue); \ handle->name##_cb = cb; \ uv__handle_start(handle); \ return 0; \ @@ -40,21 +40,21 @@ \ int uv_##name##_stop(uv_##name##_t* handle) { \ if (!uv__is_active(handle)) return 0; \ - uv__queue_remove(&handle->queue); \ + QUEUE_REMOVE(&handle->queue); \ uv__handle_stop(handle); \ return 0; \ } \ \ void uv__run_##name(uv_loop_t* loop) { \ uv_##name##_t* h; \ - struct uv__queue queue; \ - struct uv__queue* q; \ - uv__queue_move(&loop->name##_handles, &queue); \ - while (!uv__queue_empty(&queue)) { \ - q = uv__queue_head(&queue); \ - h = uv__queue_data(q, uv_##name##_t, queue); \ - uv__queue_remove(q); \ - uv__queue_insert_tail(&loop->name##_handles, q); \ + QUEUE queue; \ + QUEUE* q; \ + QUEUE_MOVE(&loop->name##_handles, &queue); \ + while (!QUEUE_EMPTY(&queue)) { \ + q = QUEUE_HEAD(&queue); \ + h = QUEUE_DATA(q, uv_##name##_t, queue); \ + QUEUE_REMOVE(q); \ + QUEUE_INSERT_TAIL(&loop->name##_handles, q); \ h->name##_cb(h); \ } \ } \ diff --git a/src/unix/loop.c b/src/unix/loop.c index 6c579de..a44019b 100644 --- a/src/unix/loop.c +++ b/src/unix/loop.c @@ -46,33 +46,29 @@ int uv_loop_init(uv_loop_t* loop) { err = uv_mutex_init(&lfields->loop_metrics.lock); if (err) goto fail_metrics_mutex_init; - memset(&lfields->loop_metrics.metrics, - 0, - sizeof(lfields->loop_metrics.metrics)); heap_init((struct heap*) &loop->timer_heap); - uv__queue_init(&loop->wq); + QUEUE_INIT(&loop->wq); #ifdef USE_FFRT uv__loop_internal_fields_t* lfields_qos = uv__get_internal_fields(loop); - uv__queue_init(&(lfields_qos->wq_sub[uv_qos_background])); - uv__queue_init(&(lfields_qos->wq_sub[uv_qos_utility])); - uv__queue_init(&(lfields_qos->wq_sub[uv_qos_default])); - uv__queue_init(&(lfields_qos->wq_sub[uv_qos_user_initiated])); + QUEUE_INIT(&(lfields_qos->wq_sub[uv_qos_background])); + QUEUE_INIT(&(lfields_qos->wq_sub[uv_qos_utility])); + QUEUE_INIT(&(lfields_qos->wq_sub[uv_qos_default])); + QUEUE_INIT(&(lfields_qos->wq_sub[uv_qos_user_initiated])); #endif - - uv__queue_init(&loop->idle_handles); - uv__queue_init(&loop->async_handles); - uv__queue_init(&loop->check_handles); - uv__queue_init(&loop->prepare_handles); - uv__queue_init(&loop->handle_queue); + QUEUE_INIT(&loop->idle_handles); + QUEUE_INIT(&loop->async_handles); + QUEUE_INIT(&loop->check_handles); + QUEUE_INIT(&loop->prepare_handles); + QUEUE_INIT(&loop->handle_queue); loop->active_handles = 0; loop->active_reqs.count = 0; loop->nfds = 0; loop->watchers = NULL; loop->nwatchers = 0; - uv__queue_init(&loop->pending_queue); - uv__queue_init(&loop->watcher_queue); + QUEUE_INIT(&loop->pending_queue); + QUEUE_INIT(&loop->watcher_queue); loop->closing_handles = NULL; uv__update_time(loop); @@ -91,10 +87,13 @@ int uv_loop_init(uv_loop_t* loop) { goto fail_platform_init; uv__signal_global_once_init(); - err = uv__process_init(loop); + err = uv_signal_init(loop, &loop->child_watcher); if (err) goto fail_signal_init; - uv__queue_init(&loop->process_handles); + + uv__handle_unref(&loop->child_watcher); + loop->child_watcher.flags |= UV_HANDLE_INTERNAL; + QUEUE_INIT(&loop->process_handles); err = uv_rwlock_init(&loop->cloexec_lock); if (err) @@ -162,9 +161,9 @@ int uv_loop_fork(uv_loop_t* loop) { if (w == NULL) continue; - if (w->pevents != 0 && uv__queue_empty(&w->watcher_queue)) { + if (w->pevents != 0 && QUEUE_EMPTY(&w->watcher_queue)) { w->events = 0; /* Force re-registration in uv__io_poll. */ - uv__queue_insert_tail(&loop->watcher_queue, &w->watcher_queue); + QUEUE_INSERT_TAIL(&loop->watcher_queue, &w->watcher_queue); } } @@ -196,13 +195,13 @@ void uv__loop_close(uv_loop_t* loop) { uv_mutex_lock(&loop->wq_mutex); #ifndef USE_FFRT - assert(uv__queue_empty(&loop->wq) && "thread pool work queue not empty!"); + assert(QUEUE_EMPTY(&loop->wq) && "thread pool work queue not empty!"); #else uv__loop_internal_fields_t* lfields_qos = uv__get_internal_fields(loop); - assert(uv__queue_empty(&(lfields_qos->wq_sub[uv_qos_background])) && "thread pool work queue qos_background not empty!"); - assert(uv__queue_empty(&(lfields_qos->wq_sub[uv_qos_utility])) && "thread pool work queue qos_utility not empty!"); - assert(uv__queue_empty(&(lfields_qos->wq_sub[uv_qos_default])) && "thread pool work queue qos_default not empty!"); - assert(uv__queue_empty(&(lfields_qos->wq_sub[uv_qos_user_initiated])) && "thread pool work queue qos_user_initiated not empty!"); + assert(QUEUE_EMPTY(&(lfields_qos->wq_sub[uv_qos_background])) && "thread pool work queue qos_background not empty!"); + assert(QUEUE_EMPTY(&(lfields_qos->wq_sub[uv_qos_utility])) && "thread pool work queue qos_utility not empty!"); + assert(QUEUE_EMPTY(&(lfields_qos->wq_sub[uv_qos_default])) && "thread pool work queue qos_default not empty!"); + assert(QUEUE_EMPTY(&(lfields_qos->wq_sub[uv_qos_user_initiated])) && "thread pool work queue qos_user_initiated not empty!"); #endif assert(!uv__has_active_reqs(loop)); uv_mutex_unlock(&loop->wq_mutex); @@ -215,8 +214,8 @@ void uv__loop_close(uv_loop_t* loop) { uv_rwlock_destroy(&loop->cloexec_lock); #if 0 - assert(uv__queue_empty(&loop->pending_queue)); - assert(uv__queue_empty(&loop->watcher_queue)); + assert(QUEUE_EMPTY(&loop->pending_queue)); + assert(QUEUE_EMPTY(&loop->watcher_queue)); assert(loop->nfds == 0); #endif diff --git a/src/unix/netbsd.c b/src/unix/netbsd.c index fa21e98..c66333f 100644 --- a/src/unix/netbsd.c +++ b/src/unix/netbsd.c @@ -103,7 +103,7 @@ uint64_t uv_get_free_memory(void) { int which[] = {CTL_VM, VM_UVMEXP}; if (sysctl(which, ARRAY_SIZE(which), &info, &size, NULL, 0)) - return 0; + return UV__ERR(errno); return (uint64_t) info.free * sysconf(_SC_PAGESIZE); } @@ -120,7 +120,7 @@ uint64_t uv_get_total_memory(void) { size_t size = sizeof(info); if (sysctl(which, ARRAY_SIZE(which), &info, &size, NULL, 0)) - return 0; + return UV__ERR(errno); return (uint64_t) info; } @@ -131,11 +131,6 @@ uint64_t uv_get_constrained_memory(void) { } -uint64_t uv_get_available_memory(void) { - return uv_get_free_memory(); -} - - int uv_resident_set_memory(size_t* rss) { kvm_t *kd = NULL; struct kinfo_proc2 *kinfo = NULL; diff --git a/src/unix/openbsd.c b/src/unix/openbsd.c index 9c863b6..f32a94d 100644 --- a/src/unix/openbsd.c +++ b/src/unix/openbsd.c @@ -116,7 +116,7 @@ uint64_t uv_get_free_memory(void) { int which[] = {CTL_VM, VM_UVMEXP}; if (sysctl(which, ARRAY_SIZE(which), &info, &size, NULL, 0)) - return 0; + return UV__ERR(errno); return (uint64_t) info.free * sysconf(_SC_PAGESIZE); } @@ -128,7 +128,7 @@ uint64_t uv_get_total_memory(void) { size_t size = sizeof(info); if (sysctl(which, ARRAY_SIZE(which), &info, &size, NULL, 0)) - return 0; + return UV__ERR(errno); return (uint64_t) info; } @@ -139,11 +139,6 @@ uint64_t uv_get_constrained_memory(void) { } -uint64_t uv_get_available_memory(void) { - return uv_get_free_memory(); -} - - int uv_resident_set_memory(size_t* rss) { struct kinfo_proc kinfo; size_t page_size = getpagesize(); diff --git a/src/unix/os390-syscalls.c b/src/unix/os390-syscalls.c index 7f90c27..5861aaa 100644 --- a/src/unix/os390-syscalls.c +++ b/src/unix/os390-syscalls.c @@ -27,7 +27,7 @@ #include #include -static struct uv__queue global_epoll_queue; +static QUEUE global_epoll_queue; static uv_mutex_t global_epoll_lock; static uv_once_t once = UV_ONCE_INIT; @@ -178,18 +178,18 @@ static void after_fork(void) { static void child_fork(void) { - struct uv__queue* q; + QUEUE* q; uv_once_t child_once = UV_ONCE_INIT; /* reset once */ memcpy(&once, &child_once, sizeof(child_once)); /* reset epoll list */ - while (!uv__queue_empty(&global_epoll_queue)) { + while (!QUEUE_EMPTY(&global_epoll_queue)) { uv__os390_epoll* lst; - q = uv__queue_head(&global_epoll_queue); - uv__queue_remove(q); - lst = uv__queue_data(q, uv__os390_epoll, member); + q = QUEUE_HEAD(&global_epoll_queue); + QUEUE_REMOVE(q); + lst = QUEUE_DATA(q, uv__os390_epoll, member); uv__free(lst->items); lst->items = NULL; lst->size = 0; @@ -201,7 +201,7 @@ static void child_fork(void) { static void epoll_init(void) { - uv__queue_init(&global_epoll_queue); + QUEUE_INIT(&global_epoll_queue); if (uv_mutex_init(&global_epoll_lock)) abort(); @@ -225,7 +225,7 @@ uv__os390_epoll* epoll_create1(int flags) { lst->items[lst->size - 1].revents = 0; uv_once(&once, epoll_init); uv_mutex_lock(&global_epoll_lock); - uv__queue_insert_tail(&global_epoll_queue, &lst->member); + QUEUE_INSERT_TAIL(&global_epoll_queue, &lst->member); uv_mutex_unlock(&global_epoll_lock); } @@ -352,14 +352,14 @@ int epoll_wait(uv__os390_epoll* lst, struct epoll_event* events, int epoll_file_close(int fd) { - struct uv__queue* q; + QUEUE* q; uv_once(&once, epoll_init); uv_mutex_lock(&global_epoll_lock); - uv__queue_foreach(q, &global_epoll_queue) { + QUEUE_FOREACH(q, &global_epoll_queue) { uv__os390_epoll* lst; - lst = uv__queue_data(q, uv__os390_epoll, member); + lst = QUEUE_DATA(q, uv__os390_epoll, member); if (fd < lst->size && lst->items != NULL && lst->items[fd].fd != -1) lst->items[fd].fd = -1; } @@ -371,7 +371,7 @@ int epoll_file_close(int fd) { void epoll_queue_close(uv__os390_epoll* lst) { /* Remove epoll instance from global queue */ uv_mutex_lock(&global_epoll_lock); - uv__queue_remove(&lst->member); + QUEUE_REMOVE(&lst->member); uv_mutex_unlock(&global_epoll_lock); /* Free resources */ diff --git a/src/unix/os390-syscalls.h b/src/unix/os390-syscalls.h index d5f3bcf..9f50417 100644 --- a/src/unix/os390-syscalls.h +++ b/src/unix/os390-syscalls.h @@ -45,7 +45,7 @@ struct epoll_event { }; typedef struct { - struct uv__queue member; + QUEUE member; struct pollfd* items; unsigned long size; int msg_queue; diff --git a/src/unix/os390.c b/src/unix/os390.c index 1b27729..3b16318 100644 --- a/src/unix/os390.c +++ b/src/unix/os390.c @@ -19,7 +19,6 @@ * IN THE SOFTWARE. */ -#include "uv.h" #include "internal.h" #include #include @@ -31,7 +30,6 @@ #include #include #include "zos-base.h" -#include "zos-sys-info.h" #if defined(__clang__) #include "csrsic.h" #else @@ -68,6 +66,9 @@ /* Total number of frames currently on all available frame queues. */ #define RCEAFC_OFFSET 0x088 +/* CPC model length from the CSRSI Service. */ +#define CPCMODEL_LENGTH 16 + /* Pointer to the home (current) ASCB. */ #define PSAAOLD 0x224 @@ -197,11 +198,6 @@ uint64_t uv_get_constrained_memory(void) { } -uint64_t uv_get_available_memory(void) { - return uv_get_free_memory(); -} - - int uv_resident_set_memory(size_t* rss) { char* ascb; char* rax; @@ -257,12 +253,9 @@ int uv_cpu_info(uv_cpu_info_t** cpu_infos, int* count) { idx = 0; while (idx < *count) { cpu_info->speed = *(int*)(info.siv1v2si22v1.si22v1cpucapability); - cpu_info->model = uv__malloc(ZOSCPU_MODEL_LENGTH + 1); - if (cpu_info->model == NULL) { - uv_free_cpu_info(*cpu_infos, idx); - return UV_ENOMEM; - } - __get_cpu_model(cpu_info->model, ZOSCPU_MODEL_LENGTH + 1); + cpu_info->model = uv__malloc(CPCMODEL_LENGTH + 1); + memset(cpu_info->model, '\0', CPCMODEL_LENGTH + 1); + memcpy(cpu_info->model, info.siv1v2si11v1.si11v1cpcmodel, CPCMODEL_LENGTH); cpu_info->cpu_times.user = cpu_usage_avg; /* TODO: implement the following */ cpu_info->cpu_times.sys = 0; @@ -810,14 +803,13 @@ static int os390_message_queue_handler(uv__os390_epoll* ep) { void uv__io_poll(uv_loop_t* loop, int timeout) { static const int max_safe_timeout = 1789569; - uv__loop_internal_fields_t* lfields; struct epoll_event events[1024]; struct epoll_event* pe; struct epoll_event e; uv__os390_epoll* ep; int have_signals; int real_timeout; - struct uv__queue* q; + QUEUE* q; uv__io_t* w; uint64_t base; int count; @@ -829,19 +821,17 @@ void uv__io_poll(uv_loop_t* loop, int timeout) { int reset_timeout; if (loop->nfds == 0) { - assert(uv__queue_empty(&loop->watcher_queue)); + assert(QUEUE_EMPTY(&loop->watcher_queue)); return; } - lfields = uv__get_internal_fields(loop); - - while (!uv__queue_empty(&loop->watcher_queue)) { + while (!QUEUE_EMPTY(&loop->watcher_queue)) { uv_stream_t* stream; - q = uv__queue_head(&loop->watcher_queue); - uv__queue_remove(q); - uv__queue_init(q); - w = uv__queue_data(q, uv__io_t, watcher_queue); + q = QUEUE_HEAD(&loop->watcher_queue); + QUEUE_REMOVE(q); + QUEUE_INIT(q); + w = QUEUE_DATA(q, uv__io_t, watcher_queue); assert(w->pevents != 0); assert(w->fd >= 0); @@ -882,7 +872,7 @@ void uv__io_poll(uv_loop_t* loop, int timeout) { int nevents = 0; have_signals = 0; - if (lfields->flags & UV_METRICS_IDLE_TIME) { + if (uv__get_internal_fields(loop)->flags & UV_METRICS_IDLE_TIME) { reset_timeout = 1; user_timeout = timeout; timeout = 0; @@ -901,12 +891,6 @@ void uv__io_poll(uv_loop_t* loop, int timeout) { if (sizeof(int32_t) == sizeof(long) && timeout >= max_safe_timeout) timeout = max_safe_timeout; - /* Store the current timeout in a location that's globally accessible so - * other locations like uv__work_done() can determine whether the queue - * of events in the callback were waiting when poll was called. - */ - lfields->current_timeout = timeout; - nfds = epoll_wait(loop->ep, events, ARRAY_SIZE(events), timeout); @@ -1014,11 +998,9 @@ void uv__io_poll(uv_loop_t* loop, int timeout) { } } - uv__metrics_inc_events(loop, nevents); if (reset_timeout != 0) { timeout = user_timeout; reset_timeout = 0; - uv__metrics_inc_events_waiting(loop, nevents); } if (have_signals != 0) { diff --git a/src/unix/pipe.c b/src/unix/pipe.c index fca3644..e8cfa14 100644 --- a/src/unix/pipe.c +++ b/src/unix/pipe.c @@ -30,19 +30,6 @@ #include -/* Does the file path contain embedded nul bytes? */ -static int includes_nul(const char *s, size_t n) { - if (n == 0) - return 0; -#ifdef __linux__ - /* Accept abstract socket namespace path ("\0/virtual/path"). */ - s++; - n--; -#endif - return NULL != memchr(s, '\0', n); -} - - int uv_pipe_init(uv_loop_t* loop, uv_pipe_t* handle, int ipc) { uv__stream_init(loop, (uv_stream_t*)handle, UV_NAMED_PIPE); handle->shutdown_req = NULL; @@ -54,63 +41,26 @@ int uv_pipe_init(uv_loop_t* loop, uv_pipe_t* handle, int ipc) { int uv_pipe_bind(uv_pipe_t* handle, const char* name) { - return uv_pipe_bind2(handle, name, strlen(name), 0); -} - - -int uv_pipe_bind2(uv_pipe_t* handle, - const char* name, - size_t namelen, - unsigned int flags) { struct sockaddr_un saddr; - char* pipe_fname; + const char* pipe_fname; int sockfd; int err; - socklen_t addrlen; pipe_fname = NULL; - if (flags & ~UV_PIPE_NO_TRUNCATE) - return UV_EINVAL; - - if (name == NULL) - return UV_EINVAL; - - if (namelen == 0) - return UV_EINVAL; - - if (includes_nul(name, namelen)) - return UV_EINVAL; - - if (flags & UV_PIPE_NO_TRUNCATE) - if (namelen > sizeof(saddr.sun_path)) - return UV_EINVAL; - - /* Truncate long paths. Documented behavior. */ - if (namelen > sizeof(saddr.sun_path)) - namelen = sizeof(saddr.sun_path); - /* Already bound? */ if (uv__stream_fd(handle) >= 0) return UV_EINVAL; - - if (uv__is_closing(handle)) + if (uv__is_closing(handle)) { return UV_EINVAL; - - /* Make a copy of the file path unless it is an abstract socket. - * We unlink the file later but abstract sockets disappear - * automatically since they're not real file system entities. - */ - if (*name == '\0') { - addrlen = offsetof(struct sockaddr_un, sun_path) + namelen; - } else { - pipe_fname = uv__malloc(namelen + 1); - if (pipe_fname == NULL) - return UV_ENOMEM; - memcpy(pipe_fname, name, namelen); - pipe_fname[namelen] = '\0'; - addrlen = sizeof saddr; } + /* Make a copy of the file name, it outlives this function's scope. */ + pipe_fname = uv__strdup(name); + if (pipe_fname == NULL) + return UV_ENOMEM; + + /* We've got a copy, don't touch the original any more. */ + name = NULL; err = uv__socket(AF_UNIX, SOCK_STREAM, 0); if (err < 0) @@ -118,10 +68,10 @@ int uv_pipe_bind2(uv_pipe_t* handle, sockfd = err; memset(&saddr, 0, sizeof saddr); - memcpy(&saddr.sun_path, name, namelen); + uv__strscpy(saddr.sun_path, pipe_fname, sizeof(saddr.sun_path)); saddr.sun_family = AF_UNIX; - if (bind(sockfd, (struct sockaddr*)&saddr, addrlen)) { + if (bind(sockfd, (struct sockaddr*)&saddr, sizeof saddr)) { err = UV__ERR(errno); /* Convert ENOENT to EACCES for compatibility with Windows. */ if (err == UV_ENOENT) @@ -133,12 +83,12 @@ int uv_pipe_bind2(uv_pipe_t* handle, /* Success. */ handle->flags |= UV_HANDLE_BOUND; - handle->pipe_fname = pipe_fname; /* NULL or a copy of |name| */ + handle->pipe_fname = pipe_fname; /* Is a strdup'ed copy. */ handle->io_watcher.fd = sockfd; return 0; err_socket: - uv__free(pipe_fname); + uv__free((void*)pipe_fname); return err; } @@ -226,56 +176,10 @@ void uv_pipe_connect(uv_connect_t* req, uv_pipe_t* handle, const char* name, uv_connect_cb cb) { - int err; - - err = uv_pipe_connect2(req, handle, name, strlen(name), 0, cb); - - if (err) { - handle->delayed_error = err; - handle->connect_req = req; - - uv__req_init(handle->loop, req, UV_CONNECT); - req->handle = (uv_stream_t*) handle; - req->cb = cb; - uv__queue_init(&req->queue); - - /* Force callback to run on next tick in case of error. */ - uv__io_feed(handle->loop, &handle->io_watcher); - } -} - - -int uv_pipe_connect2(uv_connect_t* req, - uv_pipe_t* handle, - const char* name, - size_t namelen, - unsigned int flags, - uv_connect_cb cb) { struct sockaddr_un saddr; int new_sock; int err; int r; - socklen_t addrlen; - - if (flags & ~UV_PIPE_NO_TRUNCATE) - return UV_EINVAL; - - if (name == NULL) - return UV_EINVAL; - - if (namelen == 0) - return UV_EINVAL; - - if (includes_nul(name, namelen)) - return UV_EINVAL; - - if (flags & UV_PIPE_NO_TRUNCATE) - if (namelen > sizeof(saddr.sun_path)) - return UV_EINVAL; - - /* Truncate long paths. Documented behavior. */ - if (namelen > sizeof(saddr.sun_path)) - namelen = sizeof(saddr.sun_path); new_sock = (uv__stream_fd(handle) == -1); @@ -287,16 +191,12 @@ int uv_pipe_connect2(uv_connect_t* req, } memset(&saddr, 0, sizeof saddr); - memcpy(&saddr.sun_path, name, namelen); + uv__strscpy(saddr.sun_path, name, sizeof(saddr.sun_path)); saddr.sun_family = AF_UNIX; - if (*name == '\0') - addrlen = offsetof(struct sockaddr_un, sun_path) + namelen; - else - addrlen = sizeof saddr; - do { - r = connect(uv__stream_fd(handle), (struct sockaddr*)&saddr, addrlen); + r = connect(uv__stream_fd(handle), + (struct sockaddr*)&saddr, sizeof saddr); } while (r == -1 && errno == EINTR); @@ -328,15 +228,14 @@ out: handle->connect_req = req; uv__req_init(handle->loop, req, UV_CONNECT); - req->handle = (uv_stream_t*) handle; + req->handle = (uv_stream_t*)handle; req->cb = cb; - uv__queue_init(&req->queue); + QUEUE_INIT(&req->queue); /* Force callback to run on next tick in case of error. */ if (err) uv__io_feed(handle->loop, &handle->io_watcher); - return 0; } @@ -458,7 +357,7 @@ int uv_pipe_chmod(uv_pipe_t* handle, int mode) { } /* stat must be used as fstat has a bug on Darwin */ - if (uv__stat(name_buffer, &pipe_stat) == -1) { + if (stat(name_buffer, &pipe_stat) == -1) { uv__free(name_buffer); return -errno; } diff --git a/src/unix/posix-hrtime.c b/src/unix/posix-hrtime.c index 7b45c01..323dfc2 100644 --- a/src/unix/posix-hrtime.c +++ b/src/unix/posix-hrtime.c @@ -23,14 +23,13 @@ #include "internal.h" #include -#include #include -uint64_t uv__hrtime(uv_clocktype_t type) { - struct timespec t; - - if (clock_gettime(CLOCK_MONOTONIC, &t)) - abort(); +#undef NANOSEC +#define NANOSEC ((uint64_t) 1e9) - return t.tv_sec * (uint64_t) 1e9 + t.tv_nsec; +uint64_t uv__hrtime(uv_clocktype_t type) { + struct timespec ts; + clock_gettime(CLOCK_MONOTONIC, &ts); + return (((uint64_t) ts.tv_sec) * NANOSEC + ts.tv_nsec); } diff --git a/src/unix/posix-poll.c b/src/unix/posix-poll.c index 2e016c2..0f4bf93 100644 --- a/src/unix/posix-poll.c +++ b/src/unix/posix-poll.c @@ -132,12 +132,11 @@ static void uv__pollfds_del(uv_loop_t* loop, int fd) { void uv__io_poll(uv_loop_t* loop, int timeout) { - uv__loop_internal_fields_t* lfields; sigset_t* pset; sigset_t set; uint64_t time_base; uint64_t time_diff; - struct uv__queue* q; + QUEUE* q; uv__io_t* w; size_t i; unsigned int nevents; @@ -149,19 +148,17 @@ void uv__io_poll(uv_loop_t* loop, int timeout) { int reset_timeout; if (loop->nfds == 0) { - assert(uv__queue_empty(&loop->watcher_queue)); + assert(QUEUE_EMPTY(&loop->watcher_queue)); return; } - lfields = uv__get_internal_fields(loop); - /* Take queued watchers and add their fds to our poll fds array. */ - while (!uv__queue_empty(&loop->watcher_queue)) { - q = uv__queue_head(&loop->watcher_queue); - uv__queue_remove(q); - uv__queue_init(q); + while (!QUEUE_EMPTY(&loop->watcher_queue)) { + q = QUEUE_HEAD(&loop->watcher_queue); + QUEUE_REMOVE(q); + QUEUE_INIT(q); - w = uv__queue_data(q, uv__io_t, watcher_queue); + w = QUEUE_DATA(q, uv__io_t, watcher_queue); assert(w->pevents != 0); assert(w->fd >= 0); assert(w->fd < (int) loop->nwatchers); @@ -182,7 +179,7 @@ void uv__io_poll(uv_loop_t* loop, int timeout) { assert(timeout >= -1); time_base = loop->time; - if (lfields->flags & UV_METRICS_IDLE_TIME) { + if (uv__get_internal_fields(loop)->flags & UV_METRICS_IDLE_TIME) { reset_timeout = 1; user_timeout = timeout; timeout = 0; @@ -201,12 +198,6 @@ void uv__io_poll(uv_loop_t* loop, int timeout) { if (timeout != 0) uv__metrics_set_provider_entry_time(loop); - /* Store the current timeout in a location that's globally accessible so - * other locations like uv__work_done() can determine whether the queue - * of events in the callback were waiting when poll was called. - */ - lfields->current_timeout = timeout; - if (pset != NULL) if (pthread_sigmask(SIG_BLOCK, pset, NULL)) abort(); @@ -301,11 +292,9 @@ void uv__io_poll(uv_loop_t* loop, int timeout) { } } - uv__metrics_inc_events(loop, nevents); if (reset_timeout != 0) { timeout = user_timeout; reset_timeout = 0; - uv__metrics_inc_events_waiting(loop, nevents); } if (have_signals != 0) { diff --git a/src/unix/process.c b/src/unix/process.c index 66e0660..78dce07 100644 --- a/src/unix/process.c +++ b/src/unix/process.c @@ -55,7 +55,7 @@ extern char **environ; #endif -#if defined(__linux__) +#if defined(__linux__) || defined(__GLIBC__) # include #endif @@ -79,28 +79,8 @@ static void uv__chld(uv_signal_t* handle, int signum) { assert(signum == SIGCHLD); uv__wait_children(handle->loop); } - - -int uv__process_init(uv_loop_t* loop) { - int err; - - err = uv_signal_init(loop, &loop->child_watcher); - if (err) - return err; - uv__handle_unref(&loop->child_watcher); - loop->child_watcher.flags |= UV_HANDLE_INTERNAL; - return 0; -} - - -#else -int uv__process_init(uv_loop_t* loop) { - memset(&loop->child_watcher, 0, sizeof(loop->child_watcher)); - return 0; -} #endif - void uv__wait_children(uv_loop_t* loop) { uv_process_t* process; int exit_status; @@ -108,24 +88,23 @@ void uv__wait_children(uv_loop_t* loop) { int status; int options; pid_t pid; - struct uv__queue pending; - struct uv__queue* q; - struct uv__queue* h; + QUEUE pending; + QUEUE* q; + QUEUE* h; - uv__queue_init(&pending); + QUEUE_INIT(&pending); h = &loop->process_handles; - q = uv__queue_head(h); + q = QUEUE_HEAD(h); while (q != h) { - process = uv__queue_data(q, uv_process_t, queue); - q = uv__queue_next(q); + process = QUEUE_DATA(q, uv_process_t, queue); + q = QUEUE_NEXT(q); #ifndef UV_USE_SIGCHLD if ((process->flags & UV_HANDLE_REAP) == 0) continue; options = 0; process->flags &= ~UV_HANDLE_REAP; - loop->nfds--; #else options = WNOHANG; #endif @@ -149,18 +128,18 @@ void uv__wait_children(uv_loop_t* loop) { assert(pid == process->pid); process->status = status; - uv__queue_remove(&process->queue); - uv__queue_insert_tail(&pending, &process->queue); + QUEUE_REMOVE(&process->queue); + QUEUE_INSERT_TAIL(&pending, &process->queue); } h = &pending; - q = uv__queue_head(h); + q = QUEUE_HEAD(h); while (q != h) { - process = uv__queue_data(q, uv_process_t, queue); - q = uv__queue_next(q); + process = QUEUE_DATA(q, uv_process_t, queue); + q = QUEUE_NEXT(q); - uv__queue_remove(&process->queue); - uv__queue_init(&process->queue); + QUEUE_REMOVE(&process->queue); + QUEUE_INIT(&process->queue); uv__handle_stop(process); if (process->exit_cb == NULL) @@ -176,18 +155,13 @@ void uv__wait_children(uv_loop_t* loop) { process->exit_cb(process, exit_status, term_signal); } - assert(uv__queue_empty(&pending)); + assert(QUEUE_EMPTY(&pending)); } /* * Used for initializing stdio streams like options.stdin_stream. Returns * zero on success. See also the cleanup section in uv_spawn(). */ -#if !(defined(__APPLE__) && (TARGET_OS_TV || TARGET_OS_WATCH)) -/* execvp is marked __WATCHOS_PROHIBITED __TVOS_PROHIBITED, so must be - * avoided. Since this isn't called on those targets, the function - * doesn't even need to be defined for them. - */ static int uv__process_init_stdio(uv_stdio_container_t* container, int fds[2]) { int mask; int fd; @@ -274,6 +248,11 @@ static void uv__write_errno(int error_fd) { } +#if !(defined(__APPLE__) && (TARGET_OS_TV || TARGET_OS_WATCH)) +/* execvp is marked __WATCHOS_PROHIBITED __TVOS_PROHIBITED, so must be + * avoided. Since this isn't called on those targets, the function + * doesn't even need to be defined for them. + */ static void uv__process_child_init(const uv_process_options_t* options, int stdio_count, int (*pipes)[2], @@ -405,6 +384,7 @@ static void uv__process_child_init(const uv_process_options_t* options, uv__write_errno(error_fd); } +#endif #if defined(__APPLE__) && !TARGET_OS_IPHONE @@ -685,7 +665,7 @@ static int uv__spawn_resolve_and_spawn(const uv_process_options_t* options, if (options->file == NULL) return ENOENT; - /* The environment for the child process is that of the parent unless overridden + /* The environment for the child process is that of the parent unless overriden * by options->env */ char** env = environ; if (options->env != NULL) @@ -951,7 +931,6 @@ static int uv__spawn_and_init_child( return err; } -#endif /* ISN'T TARGET_OS_TV || TARGET_OS_WATCH */ int uv_spawn(uv_loop_t* loop, uv_process_t* process, @@ -972,14 +951,13 @@ int uv_spawn(uv_loop_t* loop, assert(!(options->flags & ~(UV_PROCESS_DETACHED | UV_PROCESS_SETGID | UV_PROCESS_SETUID | - UV_PROCESS_WINDOWS_FILE_PATH_EXACT_NAME | UV_PROCESS_WINDOWS_HIDE | UV_PROCESS_WINDOWS_HIDE_CONSOLE | UV_PROCESS_WINDOWS_HIDE_GUI | UV_PROCESS_WINDOWS_VERBATIM_ARGUMENTS))); uv__handle_init(loop, (uv_handle_t*)process, UV_PROCESS); - uv__queue_init(&process->queue); + QUEUE_INIT(&process->queue); process->status = 0; stdio_count = options->stdio_count; @@ -1034,15 +1012,11 @@ int uv_spawn(uv_loop_t* loop, process->flags |= UV_HANDLE_REAP; loop->flags |= UV_LOOP_REAP_CHILDREN; } - /* This prevents uv__io_poll() from bailing out prematurely, being unaware - * that we added an event here for it to react to. We will decrement this - * again after the waitpid call succeeds. */ - loop->nfds++; #endif process->pid = pid; process->exit_cb = options->exit_cb; - uv__queue_insert_tail(&loop->process_handles, &process->queue); + QUEUE_INSERT_TAIL(&loop->process_handles, &process->queue); uv__handle_start(process); } @@ -1104,10 +1078,8 @@ int uv_kill(int pid, int signum) { void uv__process_close(uv_process_t* handle) { - uv__queue_remove(&handle->queue); + QUEUE_REMOVE(&handle->queue); uv__handle_stop(handle); -#ifdef UV_USE_SIGCHLD - if (uv__queue_empty(&handle->loop->process_handles)) + if (QUEUE_EMPTY(&handle->loop->process_handles)) uv_signal_stop(&handle->loop->child_watcher); -#endif } diff --git a/src/unix/pthread-fixes.c b/src/unix/pthread-fixes.c new file mode 100644 index 0000000..022d79c --- /dev/null +++ b/src/unix/pthread-fixes.c @@ -0,0 +1,58 @@ +/* Copyright (c) 2013, Sony Mobile Communications AB + * Copyright (c) 2012, Google Inc. + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are + met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following disclaimer + in the documentation and/or other materials provided with the + distribution. + * Neither the name of Google Inc. nor the names of its + contributors may be used to endorse or promote products derived from + this software without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ + +/* Android versions < 4.1 have a broken pthread_sigmask. */ +#include "uv-common.h" + +#include +#include +#include + +int uv__pthread_sigmask(int how, const sigset_t* set, sigset_t* oset) { + static int workaround; + int err; + + if (uv__load_relaxed(&workaround)) { + return sigprocmask(how, set, oset); + } else { + err = pthread_sigmask(how, set, oset); + if (err) { + if (err == EINVAL && sigprocmask(how, set, oset) == 0) { + uv__store_relaxed(&workaround, 1); + return 0; + } else { + return -1; + } + } + } + + return 0; +} diff --git a/src/unix/qnx.c b/src/unix/qnx.c index 57ea9df..ca148d3 100644 --- a/src/unix/qnx.c +++ b/src/unix/qnx.c @@ -88,11 +88,6 @@ uint64_t uv_get_constrained_memory(void) { } -uint64_t uv_get_available_memory(void) { - return uv_get_free_memory(); -} - - int uv_resident_set_memory(size_t* rss) { int fd; procfs_asinfo asinfo; diff --git a/src/unix/random-devurandom.c b/src/unix/random-devurandom.c index d6336f2..05e52a5 100644 --- a/src/unix/random-devurandom.c +++ b/src/unix/random-devurandom.c @@ -40,7 +40,7 @@ int uv__random_readpath(const char* path, void* buf, size_t buflen) { if (fd < 0) return fd; - if (uv__fstat(fd, &s)) { + if (fstat(fd, &s)) { uv__close(fd); return UV__ERR(errno); } diff --git a/src/unix/random-getrandom.c b/src/unix/random-getrandom.c index 054eccf..bcc9408 100644 --- a/src/unix/random-getrandom.c +++ b/src/unix/random-getrandom.c @@ -24,6 +24,8 @@ #ifdef __linux__ +#include "linux-syscalls.h" + #define uv__random_getrandom_init() 0 #else /* !__linux__ */ diff --git a/src/unix/signal.c b/src/unix/signal.c index bc4206e..1133c73 100644 --- a/src/unix/signal.c +++ b/src/unix/signal.c @@ -279,43 +279,26 @@ static int uv__signal_loop_once_init(uv_loop_t* loop) { int uv__signal_loop_fork(uv_loop_t* loop) { - struct uv__queue* q; - - if (loop->signal_pipefd[0] == -1) - return 0; uv__io_stop(loop, &loop->signal_io_watcher, POLLIN); uv__close(loop->signal_pipefd[0]); uv__close(loop->signal_pipefd[1]); loop->signal_pipefd[0] = -1; loop->signal_pipefd[1] = -1; - - uv__queue_foreach(q, &loop->handle_queue) { - uv_handle_t* handle = uv__queue_data(q, uv_handle_t, handle_queue); - uv_signal_t* sh; - - if (handle->type != UV_SIGNAL) - continue; - - sh = (uv_signal_t*) handle; - sh->caught_signals = 0; - sh->dispatched_signals = 0; - } - return uv__signal_loop_once_init(loop); } void uv__signal_loop_cleanup(uv_loop_t* loop) { - struct uv__queue* q; + QUEUE* q; /* Stop all the signal watchers that are still attached to this loop. This * ensures that the (shared) signal tree doesn't contain any invalid entries * entries, and that signal handlers are removed when appropriate. - * It's safe to use uv__queue_foreach here because the handles and the handle + * It's safe to use QUEUE_FOREACH here because the handles and the handle * queue are not modified by uv__signal_stop(). */ - uv__queue_foreach(q, &loop->handle_queue) { - uv_handle_t* handle = uv__queue_data(q, uv_handle_t, handle_queue); + QUEUE_FOREACH(q, &loop->handle_queue) { + uv_handle_t* handle = QUEUE_DATA(q, uv_handle_t, handle_queue); if (handle->type == UV_SIGNAL) uv__signal_stop((uv_signal_t*) handle); diff --git a/src/unix/spinlock.h b/src/unix/spinlock.h new file mode 100644 index 0000000..a20c83c --- /dev/null +++ b/src/unix/spinlock.h @@ -0,0 +1,53 @@ +/* Copyright (c) 2013, Ben Noordhuis + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#ifndef UV_SPINLOCK_H_ +#define UV_SPINLOCK_H_ + +#include "internal.h" /* ACCESS_ONCE, UV_UNUSED */ +#include "atomic-ops.h" + +#define UV_SPINLOCK_INITIALIZER { 0 } + +typedef struct { + int lock; +} uv_spinlock_t; + +UV_UNUSED(static void uv_spinlock_init(uv_spinlock_t* spinlock)); +UV_UNUSED(static void uv_spinlock_lock(uv_spinlock_t* spinlock)); +UV_UNUSED(static void uv_spinlock_unlock(uv_spinlock_t* spinlock)); +UV_UNUSED(static int uv_spinlock_trylock(uv_spinlock_t* spinlock)); + +UV_UNUSED(static void uv_spinlock_init(uv_spinlock_t* spinlock)) { + ACCESS_ONCE(int, spinlock->lock) = 0; +} + +UV_UNUSED(static void uv_spinlock_lock(uv_spinlock_t* spinlock)) { + while (!uv_spinlock_trylock(spinlock)) cpu_relax(); +} + +UV_UNUSED(static void uv_spinlock_unlock(uv_spinlock_t* spinlock)) { + ACCESS_ONCE(int, spinlock->lock) = 0; +} + +UV_UNUSED(static int uv_spinlock_trylock(uv_spinlock_t* spinlock)) { + /* TODO(bnoordhuis) Maybe change to a ticket lock to guarantee fair queueing. + * Not really critical until we have locks that are (frequently) contended + * for by several threads. + */ + return 0 == cmpxchgi(&spinlock->lock, 0, 1); +} + +#endif /* UV_SPINLOCK_H_ */ diff --git a/src/unix/stream.c b/src/unix/stream.c index 28c4d54..b1f6359 100644 --- a/src/unix/stream.c +++ b/src/unix/stream.c @@ -60,16 +60,6 @@ struct uv__stream_select_s { }; #endif /* defined(__APPLE__) */ -union uv__cmsg { - struct cmsghdr hdr; - /* This cannot be larger because of the IBMi PASE limitation that - * the total size of control messages cannot exceed 256 bytes. - */ - char pad[256]; -}; - -STATIC_ASSERT(256 == sizeof(union uv__cmsg)); - static void uv__stream_connect(uv_stream_t*); static void uv__write(uv_stream_t* stream); static void uv__read(uv_stream_t* stream); @@ -94,8 +84,8 @@ void uv__stream_init(uv_loop_t* loop, stream->accepted_fd = -1; stream->queued_fds = NULL; stream->delayed_error = 0; - uv__queue_init(&stream->write_queue); - uv__queue_init(&stream->write_completed_queue); + QUEUE_INIT(&stream->write_queue); + QUEUE_INIT(&stream->write_completed_queue); stream->write_queue_size = 0; if (loop->emfile_fd == -1) { @@ -439,15 +429,15 @@ int uv__stream_open(uv_stream_t* stream, int fd, int flags) { void uv__stream_flush_write_queue(uv_stream_t* stream, int error) { uv_write_t* req; - struct uv__queue* q; - while (!uv__queue_empty(&stream->write_queue)) { - q = uv__queue_head(&stream->write_queue); - uv__queue_remove(q); + QUEUE* q; + while (!QUEUE_EMPTY(&stream->write_queue)) { + q = QUEUE_HEAD(&stream->write_queue); + QUEUE_REMOVE(q); - req = uv__queue_data(q, uv_write_t, queue); + req = QUEUE_DATA(q, uv_write_t, queue); req->error = error; - uv__queue_insert_tail(&stream->write_completed_queue, &req->queue); + QUEUE_INSERT_TAIL(&stream->write_completed_queue, &req->queue); } } @@ -505,34 +495,76 @@ static int uv__emfile_trick(uv_loop_t* loop, int accept_fd) { } +#if defined(UV_HAVE_KQUEUE) +# define UV_DEC_BACKLOG(w) w->rcount--; +#else +# define UV_DEC_BACKLOG(w) /* no-op */ +#endif /* defined(UV_HAVE_KQUEUE) */ + + void uv__server_io(uv_loop_t* loop, uv__io_t* w, unsigned int events) { uv_stream_t* stream; int err; - int fd; stream = container_of(w, uv_stream_t, io_watcher); assert(events & POLLIN); assert(stream->accepted_fd == -1); assert(!(stream->flags & UV_HANDLE_CLOSING)); - fd = uv__stream_fd(stream); - err = uv__accept(fd); + uv__io_start(stream->loop, &stream->io_watcher, POLLIN); - if (err == UV_EMFILE || err == UV_ENFILE) - err = uv__emfile_trick(loop, fd); /* Shed load. */ + /* connection_cb can close the server socket while we're + * in the loop so check it on each iteration. + */ + while (uv__stream_fd(stream) != -1) { + assert(stream->accepted_fd == -1); - if (err < 0) - return; +#if defined(UV_HAVE_KQUEUE) + if (w->rcount <= 0) + return; +#endif /* defined(UV_HAVE_KQUEUE) */ + + err = uv__accept(uv__stream_fd(stream)); + if (err < 0) { + if (err == UV_EAGAIN || err == UV__ERR(EWOULDBLOCK)) + return; /* Not an error. */ - stream->accepted_fd = err; - stream->connection_cb(stream, 0); + if (err == UV_ECONNABORTED) + continue; /* Ignore. Nothing we can do about that. */ - if (stream->accepted_fd != -1) - /* The user hasn't yet accepted called uv_accept() */ - uv__io_stop(loop, &stream->io_watcher, POLLIN); + if (err == UV_EMFILE || err == UV_ENFILE) { + err = uv__emfile_trick(loop, uv__stream_fd(stream)); + if (err == UV_EAGAIN || err == UV__ERR(EWOULDBLOCK)) + break; + } + + stream->connection_cb(stream, err); + continue; + } + + UV_DEC_BACKLOG(w) + stream->accepted_fd = err; + stream->connection_cb(stream, 0); + + if (stream->accepted_fd != -1) { + /* The user hasn't yet accepted called uv_accept() */ + uv__io_stop(loop, &stream->io_watcher, POLLIN); + return; + } + + if (stream->type == UV_TCP && + (stream->flags & UV_HANDLE_TCP_SINGLE_ACCEPT)) { + /* Give other processes a chance to accept connections. */ + struct timespec timeout = { 0, 1 }; + nanosleep(&timeout, NULL); + } + } } +#undef UV_DEC_BACKLOG + + int uv_accept(uv_stream_t* server, uv_stream_t* client) { int err; @@ -627,13 +659,13 @@ static void uv__drain(uv_stream_t* stream) { uv_shutdown_t* req; int err; - assert(uv__queue_empty(&stream->write_queue)); + assert(QUEUE_EMPTY(&stream->write_queue)); if (!(stream->flags & UV_HANDLE_CLOSING)) { uv__io_stop(stream->loop, &stream->io_watcher, POLLOUT); uv__stream_osx_interrupt_select(stream); } - if (!uv__is_stream_shutting(stream)) + if (!(stream->flags & UV_HANDLE_SHUTTING)) return; req = stream->shutdown_req; @@ -642,6 +674,7 @@ static void uv__drain(uv_stream_t* stream) { if ((stream->flags & UV_HANDLE_CLOSING) || !(stream->flags & UV_HANDLE_SHUT)) { stream->shutdown_req = NULL; + stream->flags &= ~UV_HANDLE_SHUTTING; uv__req_unregister(stream->loop, req); err = 0; @@ -714,7 +747,7 @@ static void uv__write_req_finish(uv_write_t* req) { uv_stream_t* stream = req->handle; /* Pop the req off tcp->write_queue. */ - uv__queue_remove(&req->queue); + QUEUE_REMOVE(&req->queue); /* Only free when there was no error. On error, we touch up write_queue_size * right before making the callback. The reason we don't do that right away @@ -731,7 +764,7 @@ static void uv__write_req_finish(uv_write_t* req) { /* Add it to the write_completed_queue where it will have its * callback called in the near future. */ - uv__queue_insert_tail(&stream->write_completed_queue, &req->queue); + QUEUE_INSERT_TAIL(&stream->write_completed_queue, &req->queue); uv__io_feed(stream->loop, &stream->io_watcher); } @@ -779,14 +812,18 @@ static int uv__try_write(uv_stream_t* stream, if (send_handle != NULL) { int fd_to_send; struct msghdr msg; - union uv__cmsg cmsg; + struct cmsghdr *cmsg; + union { + char data[64]; + struct cmsghdr alias; + } scratch; if (uv__is_closing(send_handle)) return UV_EBADF; fd_to_send = uv__handle_fd((uv_handle_t*) send_handle); - memset(&cmsg, 0, sizeof(cmsg)); + memset(&scratch, 0, sizeof(scratch)); assert(fd_to_send >= 0); @@ -796,13 +833,20 @@ static int uv__try_write(uv_stream_t* stream, msg.msg_iovlen = iovcnt; msg.msg_flags = 0; - msg.msg_control = &cmsg.hdr; + msg.msg_control = &scratch.alias; msg.msg_controllen = CMSG_SPACE(sizeof(fd_to_send)); - cmsg.hdr.cmsg_level = SOL_SOCKET; - cmsg.hdr.cmsg_type = SCM_RIGHTS; - cmsg.hdr.cmsg_len = CMSG_LEN(sizeof(fd_to_send)); - memcpy(CMSG_DATA(&cmsg.hdr), &fd_to_send, sizeof(fd_to_send)); + cmsg = CMSG_FIRSTHDR(&msg); + cmsg->cmsg_level = SOL_SOCKET; + cmsg->cmsg_type = SCM_RIGHTS; + cmsg->cmsg_len = CMSG_LEN(sizeof(fd_to_send)); + + /* silence aliasing warning */ + { + void* pv = CMSG_DATA(cmsg); + int* pi = pv; + *pi = fd_to_send; + } do n = sendmsg(uv__stream_fd(stream), &msg, 0); @@ -837,25 +881,18 @@ static int uv__try_write(uv_stream_t* stream, } static void uv__write(uv_stream_t* stream) { - struct uv__queue* q; + QUEUE* q; uv_write_t* req; ssize_t n; - int count; assert(uv__stream_fd(stream) >= 0); - /* Prevent loop starvation when the consumer of this stream read as fast as - * (or faster than) we can write it. This `count` mechanism does not need to - * change even if we switch to edge-triggered I/O. - */ - count = 32; - for (;;) { - if (uv__queue_empty(&stream->write_queue)) + if (QUEUE_EMPTY(&stream->write_queue)) return; - q = uv__queue_head(&stream->write_queue); - req = uv__queue_data(q, uv_write_t, queue); + q = QUEUE_HEAD(&stream->write_queue); + req = QUEUE_DATA(q, uv_write_t, queue); assert(req->handle == stream); n = uv__try_write(stream, @@ -868,13 +905,10 @@ static void uv__write(uv_stream_t* stream) { req->send_handle = NULL; if (uv__write_req_update(stream, req, n)) { uv__write_req_finish(req); - if (count-- > 0) - continue; /* Start trying to write the next request. */ - - return; + return; /* TODO(bnoordhuis) Start trying to write the next request. */ } } else if (n != UV_EAGAIN) - goto error; + break; /* If this is a blocking stream, try again. */ if (stream->flags & UV_HANDLE_BLOCKING_WRITES) @@ -889,7 +923,6 @@ static void uv__write(uv_stream_t* stream) { return; } -error: req->error = n; uv__write_req_finish(req); uv__io_stop(stream->loop, &stream->io_watcher, POLLOUT); @@ -899,19 +932,19 @@ error: static void uv__write_callbacks(uv_stream_t* stream) { uv_write_t* req; - struct uv__queue* q; - struct uv__queue pq; + QUEUE* q; + QUEUE pq; - if (uv__queue_empty(&stream->write_completed_queue)) + if (QUEUE_EMPTY(&stream->write_completed_queue)) return; - uv__queue_move(&stream->write_completed_queue, &pq); + QUEUE_MOVE(&stream->write_completed_queue, &pq); - while (!uv__queue_empty(&pq)) { + while (!QUEUE_EMPTY(&pq)) { /* Pop a req off write_completed_queue. */ - q = uv__queue_head(&pq); - req = uv__queue_data(q, uv_write_t, queue); - uv__queue_remove(q); + q = QUEUE_HEAD(&pq); + req = QUEUE_DATA(q, uv_write_t, queue); + QUEUE_REMOVE(q); uv__req_unregister(stream->loop, req); if (req->bufs != NULL) { @@ -977,38 +1010,57 @@ static int uv__stream_queue_fd(uv_stream_t* stream, int fd) { } +#if defined(__PASE__) +/* on IBMi PASE the control message length can not exceed 256. */ +# define UV__CMSG_FD_COUNT 60 +#else +# define UV__CMSG_FD_COUNT 64 +#endif +#define UV__CMSG_FD_SIZE (UV__CMSG_FD_COUNT * sizeof(int)) + + static int uv__stream_recv_cmsg(uv_stream_t* stream, struct msghdr* msg) { struct cmsghdr* cmsg; - int fd; - int err; - size_t i; - size_t count; for (cmsg = CMSG_FIRSTHDR(msg); cmsg != NULL; cmsg = CMSG_NXTHDR(msg, cmsg)) { + char* start; + char* end; + int err; + void* pv; + int* pi; + unsigned int i; + unsigned int count; + if (cmsg->cmsg_type != SCM_RIGHTS) { fprintf(stderr, "ignoring non-SCM_RIGHTS ancillary data: %d\n", cmsg->cmsg_type); continue; } - assert(cmsg->cmsg_len >= CMSG_LEN(0)); - count = cmsg->cmsg_len - CMSG_LEN(0); - assert(count % sizeof(fd) == 0); - count /= sizeof(fd); + /* silence aliasing warning */ + pv = CMSG_DATA(cmsg); + pi = pv; + + /* Count available fds */ + start = (char*) cmsg; + end = (char*) cmsg + cmsg->cmsg_len; + count = 0; + while (start + CMSG_LEN(count * sizeof(*pi)) < end) + count++; + assert(start + CMSG_LEN(count * sizeof(*pi)) == end); for (i = 0; i < count; i++) { - memcpy(&fd, (char*) CMSG_DATA(cmsg) + i * sizeof(fd), sizeof(fd)); /* Already has accepted fd, queue now */ if (stream->accepted_fd != -1) { - err = uv__stream_queue_fd(stream, fd); + err = uv__stream_queue_fd(stream, pi[i]); if (err != 0) { /* Close rest */ for (; i < count; i++) - uv__close(fd); + uv__close(pi[i]); return err; } } else { - stream->accepted_fd = fd; + stream->accepted_fd = pi[i]; } } } @@ -1017,11 +1069,17 @@ static int uv__stream_recv_cmsg(uv_stream_t* stream, struct msghdr* msg) { } +#ifdef __clang__ +# pragma clang diagnostic push +# pragma clang diagnostic ignored "-Wgnu-folding-constant" +# pragma clang diagnostic ignored "-Wvla-extension" +#endif + static void uv__read(uv_stream_t* stream) { uv_buf_t buf; ssize_t nread; struct msghdr msg; - union uv__cmsg cmsg; + char cmsg_space[CMSG_SPACE(UV__CMSG_FD_SIZE)]; int count; int err; int is_ipc; @@ -1067,8 +1125,8 @@ static void uv__read(uv_stream_t* stream) { msg.msg_name = NULL; msg.msg_namelen = 0; /* Set up to receive a descriptor even if one isn't in the message */ - msg.msg_controllen = sizeof(cmsg); - msg.msg_control = &cmsg.hdr; + msg.msg_controllen = sizeof(cmsg_space); + msg.msg_control = cmsg_space; do { nread = uv__recvmsg(uv__stream_fd(stream), &msg, 0); @@ -1152,6 +1210,14 @@ static void uv__read(uv_stream_t* stream) { } +#ifdef __clang__ +# pragma clang diagnostic pop +#endif + +#undef UV__CMSG_FD_COUNT +#undef UV__CMSG_FD_SIZE + + int uv_shutdown(uv_shutdown_t* req, uv_stream_t* stream, uv_shutdown_cb cb) { assert(stream->type == UV_TCP || stream->type == UV_TTY || @@ -1159,7 +1225,7 @@ int uv_shutdown(uv_shutdown_t* req, uv_stream_t* stream, uv_shutdown_cb cb) { if (!(stream->flags & UV_HANDLE_WRITABLE) || stream->flags & UV_HANDLE_SHUT || - uv__is_stream_shutting(stream) || + stream->flags & UV_HANDLE_SHUTTING || uv__is_closing(stream)) { return UV_ENOTCONN; } @@ -1172,9 +1238,10 @@ int uv_shutdown(uv_shutdown_t* req, uv_stream_t* stream, uv_shutdown_cb cb) { req->handle = stream; req->cb = cb; stream->shutdown_req = req; + stream->flags |= UV_HANDLE_SHUTTING; stream->flags &= ~UV_HANDLE_WRITABLE; - if (uv__queue_empty(&stream->write_queue)) + if (QUEUE_EMPTY(&stream->write_queue)) uv__io_feed(stream->loop, &stream->io_watcher); return 0; @@ -1227,7 +1294,7 @@ static void uv__stream_io(uv_loop_t* loop, uv__io_t* w, unsigned int events) { uv__write_callbacks(stream); /* Write queue drained. */ - if (uv__queue_empty(&stream->write_queue)) + if (QUEUE_EMPTY(&stream->write_queue)) uv__drain(stream); } } @@ -1270,7 +1337,7 @@ static void uv__stream_connect(uv_stream_t* stream) { stream->connect_req = NULL; uv__req_unregister(stream->loop, req); - if (error < 0 || uv__queue_empty(&stream->write_queue)) { + if (error < 0 || QUEUE_EMPTY(&stream->write_queue)) { uv__io_stop(stream->loop, &stream->io_watcher, POLLOUT); } @@ -1352,7 +1419,7 @@ int uv_write2(uv_write_t* req, req->handle = stream; req->error = 0; req->send_handle = send_handle; - uv__queue_init(&req->queue); + QUEUE_INIT(&req->queue); req->bufs = req->bufsml; if (nbufs > ARRAY_SIZE(req->bufsml)) @@ -1367,7 +1434,7 @@ int uv_write2(uv_write_t* req, stream->write_queue_size += uv__count_bufs(bufs, nbufs); /* Append the request to write_queue. */ - uv__queue_insert_tail(&stream->write_queue, &req->queue); + QUEUE_INSERT_TAIL(&stream->write_queue, &req->queue); /* If the queue was empty when this function began, we should attempt to * do the write immediately. Otherwise start the write_watcher and wait diff --git a/src/unix/sunos.c b/src/unix/sunos.c index 2d6bae7..7835bed 100644 --- a/src/unix/sunos.c +++ b/src/unix/sunos.c @@ -148,7 +148,7 @@ void uv__io_poll(uv_loop_t* loop, int timeout) { struct port_event events[1024]; struct port_event* pe; struct timespec spec; - struct uv__queue* q; + QUEUE* q; uv__io_t* w; sigset_t* pset; sigset_t set; @@ -166,16 +166,16 @@ void uv__io_poll(uv_loop_t* loop, int timeout) { int reset_timeout; if (loop->nfds == 0) { - assert(uv__queue_empty(&loop->watcher_queue)); + assert(QUEUE_EMPTY(&loop->watcher_queue)); return; } - while (!uv__queue_empty(&loop->watcher_queue)) { - q = uv__queue_head(&loop->watcher_queue); - uv__queue_remove(q); - uv__queue_init(q); + while (!QUEUE_EMPTY(&loop->watcher_queue)) { + q = QUEUE_HEAD(&loop->watcher_queue); + QUEUE_REMOVE(q); + QUEUE_INIT(q); - w = uv__queue_data(q, uv__io_t, watcher_queue); + w = QUEUE_DATA(q, uv__io_t, watcher_queue); assert(w->pevents != 0); if (port_associate(loop->backend_fd, @@ -316,15 +316,13 @@ void uv__io_poll(uv_loop_t* loop, int timeout) { continue; /* Disabled by callback. */ /* Events Ports operates in oneshot mode, rearm timer on next run. */ - if (w->pevents != 0 && uv__queue_empty(&w->watcher_queue)) - uv__queue_insert_tail(&loop->watcher_queue, &w->watcher_queue); + if (w->pevents != 0 && QUEUE_EMPTY(&w->watcher_queue)) + QUEUE_INSERT_TAIL(&loop->watcher_queue, &w->watcher_queue); } - uv__metrics_inc_events(loop, nevents); if (reset_timeout != 0) { timeout = user_timeout; reset_timeout = 0; - uv__metrics_inc_events_waiting(loop, nevents); } if (have_signals != 0) { @@ -417,11 +415,6 @@ uint64_t uv_get_constrained_memory(void) { } -uint64_t uv_get_available_memory(void) { - return uv_get_free_memory(); -} - - void uv_loadavg(double avg[3]) { (void) getloadavg(avg, 3); } diff --git a/src/unix/tcp.c b/src/unix/tcp.c index 799fca7..73fc657 100644 --- a/src/unix/tcp.c +++ b/src/unix/tcp.c @@ -27,47 +27,17 @@ #include #include -#include -#include -/* ifaddrs is not implemented on AIX and IBM i PASE */ -#if !defined(_AIX) -#include -#endif - -static int maybe_bind_socket(int fd) { - union uv__sockaddr s; +static int new_socket(uv_tcp_t* handle, int domain, unsigned long flags) { + struct sockaddr_storage saddr; socklen_t slen; - - slen = sizeof(s); - memset(&s, 0, sizeof(s)); - - if (getsockname(fd, &s.addr, &slen)) - return UV__ERR(errno); - - if (s.addr.sa_family == AF_INET) - if (s.in.sin_port != 0) - return 0; /* Already bound to a port. */ - - if (s.addr.sa_family == AF_INET6) - if (s.in6.sin6_port != 0) - return 0; /* Already bound to a port. */ - - /* Bind to an arbitrary port. */ - if (bind(fd, &s.addr, slen)) - return UV__ERR(errno); - - return 0; -} - - -static int new_socket(uv_tcp_t* handle, int domain, unsigned int flags) { int sockfd; int err; - sockfd = uv__socket(domain, SOCK_STREAM, 0); - if (sockfd < 0) - return sockfd; + err = uv__socket(domain, SOCK_STREAM, 0); + if (err < 0) + return err; + sockfd = err; err = uv__stream_open((uv_stream_t*) handle, sockfd, flags); if (err) { @@ -75,44 +45,74 @@ static int new_socket(uv_tcp_t* handle, int domain, unsigned int flags) { return err; } - if (flags & UV_HANDLE_BOUND) - return maybe_bind_socket(sockfd); + if (flags & UV_HANDLE_BOUND) { + /* Bind this new socket to an arbitrary port */ + slen = sizeof(saddr); + memset(&saddr, 0, sizeof(saddr)); + if (getsockname(uv__stream_fd(handle), (struct sockaddr*) &saddr, &slen)) { + uv__close(sockfd); + return UV__ERR(errno); + } + + if (bind(uv__stream_fd(handle), (struct sockaddr*) &saddr, slen)) { + uv__close(sockfd); + return UV__ERR(errno); + } + } return 0; } -static int maybe_new_socket(uv_tcp_t* handle, int domain, unsigned int flags) { - int sockfd; - int err; - - if (domain == AF_UNSPEC) - goto out; - - sockfd = uv__stream_fd(handle); - if (sockfd == -1) - return new_socket(handle, domain, flags); +static int maybe_new_socket(uv_tcp_t* handle, int domain, unsigned long flags) { + struct sockaddr_storage saddr; + socklen_t slen; - if (!(flags & UV_HANDLE_BOUND)) - goto out; + if (domain == AF_UNSPEC) { + handle->flags |= flags; + return 0; + } - if (handle->flags & UV_HANDLE_BOUND) - goto out; /* Already bound to a port. */ + if (uv__stream_fd(handle) != -1) { - err = maybe_bind_socket(sockfd); - if (err) - return err; + if (flags & UV_HANDLE_BOUND) { + + if (handle->flags & UV_HANDLE_BOUND) { + /* It is already bound to a port. */ + handle->flags |= flags; + return 0; + } + + /* Query to see if tcp socket is bound. */ + slen = sizeof(saddr); + memset(&saddr, 0, sizeof(saddr)); + if (getsockname(uv__stream_fd(handle), (struct sockaddr*) &saddr, &slen)) + return UV__ERR(errno); + + if ((saddr.ss_family == AF_INET6 && + ((struct sockaddr_in6*) &saddr)->sin6_port != 0) || + (saddr.ss_family == AF_INET && + ((struct sockaddr_in*) &saddr)->sin_port != 0)) { + /* Handle is already bound to a port. */ + handle->flags |= flags; + return 0; + } + + /* Bind to arbitrary port */ + if (bind(uv__stream_fd(handle), (struct sockaddr*) &saddr, slen)) + return UV__ERR(errno); + } -out: + handle->flags |= flags; + return 0; + } - handle->flags |= flags; - return 0; + return new_socket(handle, domain, flags); } int uv_tcp_init_ex(uv_loop_t* loop, uv_tcp_t* tcp, unsigned int flags) { int domain; - int err; /* Use the lower 8 bits for the domain */ domain = flags & 0xFF; @@ -129,12 +129,9 @@ int uv_tcp_init_ex(uv_loop_t* loop, uv_tcp_t* tcp, unsigned int flags) { */ if (domain != AF_UNSPEC) { - err = new_socket(tcp, domain, 0); + int err = maybe_new_socket(tcp, domain, 0); if (err) { - uv__queue_remove(&tcp->handle_queue); - if (tcp->io_watcher.fd != -1) - uv__close(tcp->io_watcher.fd); - tcp->io_watcher.fd = -1; + QUEUE_REMOVE(&tcp->handle_queue); return err; } } @@ -205,75 +202,11 @@ int uv__tcp_bind(uv_tcp_t* tcp, } -static int uv__is_ipv6_link_local(const struct sockaddr* addr) { - const struct sockaddr_in6* a6; - uint8_t b[2]; - - if (addr->sa_family != AF_INET6) - return 0; - - a6 = (const struct sockaddr_in6*) addr; - memcpy(b, &a6->sin6_addr, sizeof(b)); - - return b[0] == 0xFE && b[1] == 0x80; -} - - -static int uv__ipv6_link_local_scope_id(void) { - struct sockaddr_in6* a6; - int rv; -#if defined(_AIX) - /* AIX & IBM i do not have ifaddrs - * so fallback to use uv_interface_addresses */ - uv_interface_address_t* interfaces; - uv_interface_address_t* ifa; - int count, i; - - if (uv_interface_addresses(&interfaces, &count)) - return 0; - - rv = 0; - - for (ifa = interfaces; ifa != &interfaces[count]; ifa++) { - if (uv__is_ipv6_link_local((struct sockaddr*) &ifa->address)) { - rv = ifa->address.address6.sin6_scope_id; - break; - } - } - - uv_free_interface_addresses(interfaces, count); - -#else - struct ifaddrs* ifa; - struct ifaddrs* p; - - if (getifaddrs(&ifa)) - return 0; - - for (p = ifa; p != NULL; p = p->ifa_next) - if (p->ifa_addr != NULL) - if (uv__is_ipv6_link_local(p->ifa_addr)) - break; - - rv = 0; - if (p != NULL) { - a6 = (struct sockaddr_in6*) p->ifa_addr; - rv = a6->sin6_scope_id; - } - - freeifaddrs(ifa); -#endif /* defined(_AIX) */ - - return rv; -} - - int uv__tcp_connect(uv_connect_t* req, uv_tcp_t* handle, const struct sockaddr* addr, unsigned int addrlen, uv_connect_cb cb) { - struct sockaddr_in6 tmp6; int err; int r; @@ -291,14 +224,6 @@ int uv__tcp_connect(uv_connect_t* req, if (err) return err; - if (uv__is_ipv6_link_local(addr)) { - memcpy(&tmp6, addr, sizeof(tmp6)); - if (tmp6.sin6_scope_id == 0) { - tmp6.sin6_scope_id = uv__ipv6_link_local_scope_id(); - addr = (void*) &tmp6; - } - } - do { errno = 0; r = connect(uv__stream_fd(handle), addr, addrlen); @@ -331,7 +256,7 @@ out: uv__req_init(handle->loop, req, UV_CONNECT); req->cb = cb; req->handle = (uv_stream_t*) handle; - uv__queue_init(&req->queue); + QUEUE_INIT(&req->queue); handle->connect_req = req; uv__io_start(handle->loop, &handle->io_watcher, POLLOUT); @@ -392,7 +317,7 @@ int uv_tcp_close_reset(uv_tcp_t* handle, uv_close_cb close_cb) { struct linger l = { 1, 0 }; /* Disallow setting SO_LINGER to zero due to some platform inconsistencies */ - if (uv__is_stream_shutting(handle)) + if (handle->flags & UV_HANDLE_SHUTTING) return UV_EINVAL; fd = uv__stream_fd(handle); @@ -413,12 +338,24 @@ int uv_tcp_close_reset(uv_tcp_t* handle, uv_close_cb close_cb) { int uv__tcp_listen(uv_tcp_t* tcp, int backlog, uv_connection_cb cb) { - unsigned int flags; + static int single_accept_cached = -1; + unsigned long flags; + int single_accept; int err; if (tcp->delayed_error) return tcp->delayed_error; + single_accept = uv__load_relaxed(&single_accept_cached); + if (single_accept == -1) { + const char* val = getenv("UV_TCP_SINGLE_ACCEPT"); + single_accept = (val != NULL && atoi(val) != 0); /* Off by default. */ + uv__store_relaxed(&single_accept_cached, single_accept); + } + + if (single_accept) + tcp->flags |= UV_HANDLE_TCP_SINGLE_ACCEPT; + flags = 0; #if defined(__MVS__) /* on zOS the listen call does not bind automatically @@ -453,108 +390,31 @@ int uv__tcp_nodelay(int fd, int on) { int uv__tcp_keepalive(int fd, int on, unsigned int delay) { - int idle; - int intvl; - int cnt; - - (void) &idle; - (void) &intvl; - (void) &cnt; - if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &on, sizeof(on))) return UV__ERR(errno); - if (!on) - return 0; - - if (delay == 0) - return -1; - -#ifdef __sun - /* The implementation of TCP keep-alive on Solaris/SmartOS is a bit unusual - * compared to other Unix-like systems. - * Thus, we need to specialize it on Solaris. - * - * There are two keep-alive mechanisms on Solaris: - * - By default, the first keep-alive probe is sent out after a TCP connection is idle for two hours. - * If the peer does not respond to the probe within eight minutes, the TCP connection is aborted. - * You can alter the interval for sending out the first probe using the socket option TCP_KEEPALIVE_THRESHOLD - * in milliseconds or TCP_KEEPIDLE in seconds. - * The system default is controlled by the TCP ndd parameter tcp_keepalive_interval. The minimum value is ten seconds. - * The maximum is ten days, while the default is two hours. If you receive no response to the probe, - * you can use the TCP_KEEPALIVE_ABORT_THRESHOLD socket option to change the time threshold for aborting a TCP connection. - * The option value is an unsigned integer in milliseconds. The value zero indicates that TCP should never time out and - * abort the connection when probing. The system default is controlled by the TCP ndd parameter tcp_keepalive_abort_interval. - * The default is eight minutes. - * - * - The second implementation is activated if socket option TCP_KEEPINTVL and/or TCP_KEEPCNT are set. - * The time between each consequent probes is set by TCP_KEEPINTVL in seconds. - * The minimum value is ten seconds. The maximum is ten days, while the default is two hours. - * The TCP connection will be aborted after certain amount of probes, which is set by TCP_KEEPCNT, without receiving response. - */ - - idle = delay; - /* Kernel expects at least 10 seconds. */ - if (idle < 10) - idle = 10; - /* Kernel expects at most 10 days. */ - if (idle > 10*24*60*60) - idle = 10*24*60*60; - - /* `TCP_KEEPIDLE`, `TCP_KEEPINTVL`, and `TCP_KEEPCNT` were not available on Solaris - * until version 11.4, but let's take a chance here. */ -#if defined(TCP_KEEPIDLE) && defined(TCP_KEEPINTVL) && defined(TCP_KEEPCNT) - if (setsockopt(fd, IPPROTO_TCP, TCP_KEEPIDLE, &idle, sizeof(idle))) - return UV__ERR(errno); - - intvl = idle/3; - if (setsockopt(fd, IPPROTO_TCP, TCP_KEEPINTVL, &intvl, sizeof(intvl))) - return UV__ERR(errno); - - cnt = 3; - if (setsockopt(fd, IPPROTO_TCP, TCP_KEEPCNT, &cnt, sizeof(cnt))) - return UV__ERR(errno); -#else - /* Fall back to the first implementation of tcp-alive mechanism for older Solaris, - * simulate the tcp-alive mechanism on other platforms via `TCP_KEEPALIVE_THRESHOLD` + `TCP_KEEPALIVE_ABORT_THRESHOLD`. - */ - idle *= 1000; /* kernel expects milliseconds */ - if (setsockopt(fd, IPPROTO_TCP, TCP_KEEPALIVE_THRESHOLD, &idle, sizeof(idle))) - return UV__ERR(errno); - - /* Note that the consequent probes will not be sent at equal intervals on Solaris, - * but will be sent using the exponential backoff algorithm. */ - intvl = idle/3; - cnt = 3; - int time_to_abort = intvl * cnt; - if (setsockopt(fd, IPPROTO_TCP, TCP_KEEPALIVE_ABORT_THRESHOLD, &time_to_abort, sizeof(time_to_abort))) - return UV__ERR(errno); -#endif - -#else /* !defined(__sun) */ - #ifdef TCP_KEEPIDLE - if (setsockopt(fd, IPPROTO_TCP, TCP_KEEPIDLE, &delay, sizeof(delay))) - return UV__ERR(errno); -#elif defined(TCP_KEEPALIVE) - /* Darwin/macOS uses TCP_KEEPALIVE in place of TCP_KEEPIDLE. */ - if (setsockopt(fd, IPPROTO_TCP, TCP_KEEPALIVE, &delay, sizeof(delay))) - return UV__ERR(errno); -#endif - -#ifdef TCP_KEEPINTVL - intvl = 1; /* 1 second; same as default on Win32 */ - if (setsockopt(fd, IPPROTO_TCP, TCP_KEEPINTVL, &intvl, sizeof(intvl))) - return UV__ERR(errno); + if (on) { + int intvl = 1; /* 1 second; same as default on Win32 */ + int cnt = 10; /* 10 retries; same as hardcoded on Win32 */ + if (setsockopt(fd, IPPROTO_TCP, TCP_KEEPIDLE, &delay, sizeof(delay))) + return UV__ERR(errno); + if (setsockopt(fd, IPPROTO_TCP, TCP_KEEPINTVL, &intvl, sizeof(intvl))) + return UV__ERR(errno); + if (setsockopt(fd, IPPROTO_TCP, TCP_KEEPCNT, &cnt, sizeof(cnt))) + return UV__ERR(errno); + } #endif -#ifdef TCP_KEEPCNT - cnt = 10; /* 10 retries; same as hardcoded on Win32 */ - if (setsockopt(fd, IPPROTO_TCP, TCP_KEEPCNT, &cnt, sizeof(cnt))) + /* Solaris/SmartOS, if you don't support keep-alive, + * then don't advertise it in your system headers... + */ + /* FIXME(bnoordhuis) That's possibly because sizeof(delay) should be 1. */ +#if defined(TCP_KEEPALIVE) && !defined(__sun) + if (on && setsockopt(fd, IPPROTO_TCP, TCP_KEEPALIVE, &delay, sizeof(delay))) return UV__ERR(errno); #endif -#endif /* !defined(__sun) */ return 0; } @@ -600,6 +460,10 @@ int uv_tcp_keepalive(uv_tcp_t* handle, int on, unsigned int delay) { int uv_tcp_simultaneous_accepts(uv_tcp_t* handle, int enable) { + if (enable) + handle->flags &= ~UV_HANDLE_TCP_SINGLE_ACCEPT; + else + handle->flags |= UV_HANDLE_TCP_SINGLE_ACCEPT; return 0; } diff --git a/src/unix/thread.c b/src/unix/thread.c index f05e6fe..d89e5cd 100644 --- a/src/unix/thread.c +++ b/src/unix/thread.c @@ -41,19 +41,126 @@ #include /* gnu_get_libc_version() */ #endif -#if defined(__linux__) -# include -# define uv__cpu_set_t cpu_set_t -#elif defined(__FreeBSD__) -# include -# include -# include -# define uv__cpu_set_t cpuset_t +#undef NANOSEC +#define NANOSEC ((uint64_t) 1e9) + +#if defined(PTHREAD_BARRIER_SERIAL_THREAD) +STATIC_ASSERT(sizeof(uv_barrier_t) == sizeof(pthread_barrier_t)); #endif +/* Note: guard clauses should match uv_barrier_t's in include/uv/unix.h. */ +#if defined(_AIX) || \ + defined(__OpenBSD__) || \ + !defined(PTHREAD_BARRIER_SERIAL_THREAD) +int uv_barrier_init(uv_barrier_t* barrier, unsigned int count) { + struct _uv_barrier* b; + int rc; + + if (barrier == NULL || count == 0) + return UV_EINVAL; + + b = uv__malloc(sizeof(*b)); + if (b == NULL) + return UV_ENOMEM; + + b->in = 0; + b->out = 0; + b->threshold = count; + + rc = uv_mutex_init(&b->mutex); + if (rc != 0) + goto error2; + + rc = uv_cond_init(&b->cond); + if (rc != 0) + goto error; + + barrier->b = b; + return 0; + +error: + uv_mutex_destroy(&b->mutex); +error2: + uv__free(b); + return rc; +} + + +int uv_barrier_wait(uv_barrier_t* barrier) { + struct _uv_barrier* b; + int last; + + if (barrier == NULL || barrier->b == NULL) + return UV_EINVAL; + + b = barrier->b; + uv_mutex_lock(&b->mutex); + + if (++b->in == b->threshold) { + b->in = 0; + b->out = b->threshold; + uv_cond_signal(&b->cond); + } else { + do + uv_cond_wait(&b->cond, &b->mutex); + while (b->in != 0); + } + + last = (--b->out == 0); + uv_cond_signal(&b->cond); + + uv_mutex_unlock(&b->mutex); + return last; +} + + +void uv_barrier_destroy(uv_barrier_t* barrier) { + struct _uv_barrier* b; + + b = barrier->b; + uv_mutex_lock(&b->mutex); + + assert(b->in == 0); + while (b->out != 0) + uv_cond_wait(&b->cond, &b->mutex); + + if (b->in != 0) + abort(); + + uv_mutex_unlock(&b->mutex); + uv_mutex_destroy(&b->mutex); + uv_cond_destroy(&b->cond); + + uv__free(barrier->b); + barrier->b = NULL; +} + +#else + +int uv_barrier_init(uv_barrier_t* barrier, unsigned int count) { + return UV__ERR(pthread_barrier_init(barrier, NULL, count)); +} + + +int uv_barrier_wait(uv_barrier_t* barrier) { + int rc; + + rc = pthread_barrier_wait(barrier); + if (rc != 0) + if (rc != PTHREAD_BARRIER_SERIAL_THREAD) + abort(); + + return rc == PTHREAD_BARRIER_SERIAL_THREAD; +} + + +void uv_barrier_destroy(uv_barrier_t* barrier) { + if (pthread_barrier_destroy(barrier)) + abort(); +} + +#endif -#undef NANOSEC -#define NANOSEC ((uint64_t) 1e9) /* Musl's PTHREAD_STACK_MIN is 2 KB on all architectures, which is * too small to safely receive signals on. @@ -177,106 +284,6 @@ int uv_thread_create_ex(uv_thread_t* tid, return UV__ERR(err); } -#if UV__CPU_AFFINITY_SUPPORTED - -int uv_thread_setaffinity(uv_thread_t* tid, - char* cpumask, - char* oldmask, - size_t mask_size) { - int i; - int r; - uv__cpu_set_t cpuset; - int cpumasksize; - - cpumasksize = uv_cpumask_size(); - if (cpumasksize < 0) - return cpumasksize; - if (mask_size < (size_t)cpumasksize) - return UV_EINVAL; - - if (oldmask != NULL) { - r = uv_thread_getaffinity(tid, oldmask, mask_size); - if (r < 0) - return r; - } - - CPU_ZERO(&cpuset); - for (i = 0; i < cpumasksize; i++) - if (cpumask[i]) - CPU_SET(i, &cpuset); - -#if defined(__ANDROID__) - if (sched_setaffinity(pthread_gettid_np(*tid), sizeof(cpuset), &cpuset)) - r = errno; - else - r = 0; -#else - r = pthread_setaffinity_np(*tid, sizeof(cpuset), &cpuset); -#endif - - return UV__ERR(r); -} - - -int uv_thread_getaffinity(uv_thread_t* tid, - char* cpumask, - size_t mask_size) { - int r; - int i; - uv__cpu_set_t cpuset; - int cpumasksize; - - cpumasksize = uv_cpumask_size(); - if (cpumasksize < 0) - return cpumasksize; - if (mask_size < (size_t)cpumasksize) - return UV_EINVAL; - - CPU_ZERO(&cpuset); -#if defined(__ANDROID__) - if (sched_getaffinity(pthread_gettid_np(*tid), sizeof(cpuset), &cpuset)) - r = errno; - else - r = 0; -#else - r = pthread_getaffinity_np(*tid, sizeof(cpuset), &cpuset); -#endif - if (r) - return UV__ERR(r); - for (i = 0; i < cpumasksize; i++) - cpumask[i] = !!CPU_ISSET(i, &cpuset); - - return 0; -} -#else -int uv_thread_setaffinity(uv_thread_t* tid, - char* cpumask, - char* oldmask, - size_t mask_size) { - return UV_ENOTSUP; -} - - -int uv_thread_getaffinity(uv_thread_t* tid, - char* cpumask, - size_t mask_size) { - return UV_ENOTSUP; -} -#endif /* defined(__linux__) || defined(UV_BSD_H) */ - -int uv_thread_getcpu(void) { -#if UV__CPU_AFFINITY_SUPPORTED - int cpu; - - cpu = sched_getcpu(); - if (cpu < 0) - return UV__ERR(errno); - - return cpu; -#else - return UV_ENOTSUP; -#endif -} uv_thread_t uv_thread_self(void) { return pthread_self(); @@ -578,7 +585,7 @@ static void uv__custom_sem_post(uv_sem_t* sem_) { uv_mutex_lock(&sem->mutex); sem->value++; if (sem->value == 1) - uv_cond_signal(&sem->cond); /* Release one to replace us. */ + uv_cond_signal(&sem->cond); uv_mutex_unlock(&sem->mutex); } @@ -789,33 +796,11 @@ void uv_cond_broadcast(uv_cond_t* cond) { abort(); } -#if defined(__APPLE__) && defined(__MACH__) - -void uv_cond_wait(uv_cond_t* cond, uv_mutex_t* mutex) { - int r; - - errno = 0; - r = pthread_cond_wait(cond, mutex); - - /* Workaround for a bug in OS X at least up to 13.6 - * See https://github.com/libuv/libuv/issues/4165 - */ - if (r == EINVAL) - if (errno == EBUSY) - return; - - if (r) - abort(); -} - -#else /* !(defined(__APPLE__) && defined(__MACH__)) */ - void uv_cond_wait(uv_cond_t* cond, uv_mutex_t* mutex) { if (pthread_cond_wait(cond, mutex)) abort(); } -#endif int uv_cond_timedwait(uv_cond_t* cond, uv_mutex_t* mutex, uint64_t timeout) { int r; diff --git a/src/unix/tty.c b/src/unix/tty.c index d099bdb..b415052 100644 --- a/src/unix/tty.c +++ b/src/unix/tty.c @@ -21,8 +21,8 @@ #include "uv.h" #include "internal.h" +#include "spinlock.h" -#include #include #include #include @@ -64,7 +64,7 @@ static int isreallyatty(int file) { static int orig_termios_fd = -1; static struct termios orig_termios; -static _Atomic int termios_spinlock; +static uv_spinlock_t termios_spinlock = UV_SPINLOCK_INITIALIZER; int uv__tcsetattr(int fd, int how, const struct termios *term) { int rc; @@ -81,7 +81,7 @@ int uv__tcsetattr(int fd, int how, const struct termios *term) { static int uv__tty_is_slave(const int fd) { int result; -#if defined(__linux__) || defined(__FreeBSD__) +#if defined(__linux__) || defined(__FreeBSD__) || defined(__FreeBSD_kernel__) int dummy; result = ioctl(fd, TIOCGPTN, &dummy) != 0; @@ -113,7 +113,7 @@ static int uv__tty_is_slave(const int fd) { } /* Lookup stat structure behind the file descriptor. */ - if (uv__fstat(fd, &sb) != 0) + if (fstat(fd, &sb) != 0) abort(); /* Assert character device. */ @@ -222,7 +222,7 @@ skip: int rc = r; if (newfd != -1) uv__close(newfd); - uv__queue_remove(&tty->handle_queue); + QUEUE_REMOVE(&tty->handle_queue); do r = fcntl(fd, F_SETFL, saved_flags); while (r == -1 && errno == EINTR); @@ -280,7 +280,6 @@ static void uv__tty_make_raw(struct termios* tio) { int uv_tty_set_mode(uv_tty_t* tty, uv_tty_mode_t mode) { struct termios tmp; - int expected; int fd; int rc; @@ -297,16 +296,12 @@ int uv_tty_set_mode(uv_tty_t* tty, uv_tty_mode_t mode) { return UV__ERR(errno); /* This is used for uv_tty_reset_mode() */ - do - expected = 0; - while (!atomic_compare_exchange_strong(&termios_spinlock, &expected, 1)); - + uv_spinlock_lock(&termios_spinlock); if (orig_termios_fd == -1) { orig_termios = tty->orig_termios; orig_termios_fd = fd; } - - atomic_store(&termios_spinlock, 0); + uv_spinlock_unlock(&termios_spinlock); } tmp = tty->orig_termios; @@ -365,7 +360,7 @@ uv_handle_type uv_guess_handle(uv_file file) { if (isatty(file)) return UV_TTY; - if (uv__fstat(file, &s)) { + if (fstat(file, &s)) { #if defined(__PASE__) /* On ibmi receiving RST from TCP instead of FIN immediately puts fd into * an error state. fstat will return EINVAL, getsockname will also return @@ -450,15 +445,14 @@ int uv_tty_reset_mode(void) { int err; saved_errno = errno; - - if (atomic_exchange(&termios_spinlock, 1)) + if (!uv_spinlock_trylock(&termios_spinlock)) return UV_EBUSY; /* In uv_tty_set_mode(). */ err = 0; if (orig_termios_fd != -1) err = uv__tcsetattr(orig_termios_fd, TCSANOW, &orig_termios); - atomic_store(&termios_spinlock, 0); + uv_spinlock_unlock(&termios_spinlock); errno = saved_errno; return err; diff --git a/src/unix/udp.c b/src/unix/udp.c index c281451..4d985b8 100644 --- a/src/unix/udp.c +++ b/src/unix/udp.c @@ -40,6 +40,12 @@ # define IPV6_DROP_MEMBERSHIP IPV6_LEAVE_GROUP #endif +union uv__sockaddr { + struct sockaddr_in6 in6; + struct sockaddr_in in; + struct sockaddr addr; +}; + static void uv__udp_run_completed(uv_udp_t* handle); static void uv__udp_io(uv_loop_t* loop, uv__io_t* w, unsigned int revents); static void uv__udp_recvmsg(uv_udp_t* handle); @@ -48,6 +54,36 @@ static int uv__udp_maybe_deferred_bind(uv_udp_t* handle, int domain, unsigned int flags); +#if HAVE_MMSG + +#define UV__MMSG_MAXWIDTH 20 + +static int uv__udp_recvmmsg(uv_udp_t* handle, uv_buf_t* buf); +static void uv__udp_sendmmsg(uv_udp_t* handle); + +static int uv__recvmmsg_avail; +static int uv__sendmmsg_avail; +static uv_once_t once = UV_ONCE_INIT; + +static void uv__udp_mmsg_init(void) { + int ret; + int s; + s = uv__socket(AF_INET, SOCK_DGRAM, 0); + if (s < 0) + return; + ret = uv__sendmmsg(s, NULL, 0); + if (ret == 0 || errno != ENOSYS) { + uv__sendmmsg_avail = 1; + uv__recvmmsg_avail = 1; + } else { + ret = uv__recvmmsg(s, NULL, 0); + if (ret == 0 || errno != ENOSYS) + uv__recvmmsg_avail = 1; + } + uv__close(s); +} + +#endif void uv__udp_close(uv_udp_t* handle) { uv__io_close(handle->loop, &handle->io_watcher); @@ -62,18 +98,18 @@ void uv__udp_close(uv_udp_t* handle) { void uv__udp_finish_close(uv_udp_t* handle) { uv_udp_send_t* req; - struct uv__queue* q; + QUEUE* q; assert(!uv__io_active(&handle->io_watcher, POLLIN | POLLOUT)); assert(handle->io_watcher.fd == -1); - while (!uv__queue_empty(&handle->write_queue)) { - q = uv__queue_head(&handle->write_queue); - uv__queue_remove(q); + while (!QUEUE_EMPTY(&handle->write_queue)) { + q = QUEUE_HEAD(&handle->write_queue); + QUEUE_REMOVE(q); - req = uv__queue_data(q, uv_udp_send_t, queue); + req = QUEUE_DATA(q, uv_udp_send_t, queue); req->status = UV_ECANCELED; - uv__queue_insert_tail(&handle->write_completed_queue, &req->queue); + QUEUE_INSERT_TAIL(&handle->write_completed_queue, &req->queue); } uv__udp_run_completed(handle); @@ -90,16 +126,16 @@ void uv__udp_finish_close(uv_udp_t* handle) { static void uv__udp_run_completed(uv_udp_t* handle) { uv_udp_send_t* req; - struct uv__queue* q; + QUEUE* q; assert(!(handle->flags & UV_HANDLE_UDP_PROCESSING)); handle->flags |= UV_HANDLE_UDP_PROCESSING; - while (!uv__queue_empty(&handle->write_completed_queue)) { - q = uv__queue_head(&handle->write_completed_queue); - uv__queue_remove(q); + while (!QUEUE_EMPTY(&handle->write_completed_queue)) { + q = QUEUE_HEAD(&handle->write_completed_queue); + QUEUE_REMOVE(q); - req = uv__queue_data(q, uv_udp_send_t, queue); + req = QUEUE_DATA(q, uv_udp_send_t, queue); uv__req_unregister(handle->loop, req); handle->send_queue_size -= uv__count_bufs(req->bufs, req->nbufs); @@ -121,7 +157,7 @@ static void uv__udp_run_completed(uv_udp_t* handle) { req->send_cb(req, req->status); } - if (uv__queue_empty(&handle->write_queue)) { + if (QUEUE_EMPTY(&handle->write_queue)) { /* Pending queue and completion queue empty, stop watcher. */ uv__io_stop(handle->loop, &handle->io_watcher, POLLOUT); if (!uv__io_active(&handle->io_watcher, POLLIN)) @@ -147,11 +183,11 @@ static void uv__udp_io(uv_loop_t* loop, uv__io_t* w, unsigned int revents) { } } +#if HAVE_MMSG static int uv__udp_recvmmsg(uv_udp_t* handle, uv_buf_t* buf) { -#if defined(__linux__) || defined(__FreeBSD__) - struct sockaddr_in6 peers[20]; - struct iovec iov[ARRAY_SIZE(peers)]; - struct mmsghdr msgs[ARRAY_SIZE(peers)]; + struct sockaddr_in6 peers[UV__MMSG_MAXWIDTH]; + struct iovec iov[UV__MMSG_MAXWIDTH]; + struct uv__mmsghdr msgs[UV__MMSG_MAXWIDTH]; ssize_t nread; uv_buf_t chunk_buf; size_t chunks; @@ -176,7 +212,7 @@ static int uv__udp_recvmmsg(uv_udp_t* handle, uv_buf_t* buf) { } do - nread = recvmmsg(handle->io_watcher.fd, msgs, chunks, 0, NULL); + nread = uv__recvmmsg(handle->io_watcher.fd, msgs, chunks); while (nread == -1 && errno == EINTR); if (nread < 1) { @@ -204,10 +240,8 @@ static int uv__udp_recvmmsg(uv_udp_t* handle, uv_buf_t* buf) { handle->recv_cb(handle, 0, buf, NULL, UV_UDP_MMSG_FREE); } return nread; -#else /* __linux__ || ____FreeBSD__ */ - return UV_ENOSYS; -#endif /* __linux__ || ____FreeBSD__ */ } +#endif static void uv__udp_recvmsg(uv_udp_t* handle) { struct sockaddr_storage peer; @@ -234,12 +268,14 @@ static void uv__udp_recvmsg(uv_udp_t* handle) { } assert(buf.base != NULL); +#if HAVE_MMSG if (uv_udp_using_recvmmsg(handle)) { nread = uv__udp_recvmmsg(handle, &buf); if (nread > 0) count -= nread; continue; } +#endif memset(&h, 0, sizeof(h)); memset(&peer, 0, sizeof(peer)); @@ -275,25 +311,25 @@ static void uv__udp_recvmsg(uv_udp_t* handle) { && handle->recv_cb != NULL); } -static void uv__udp_sendmsg(uv_udp_t* handle) { -#if defined(__linux__) || defined(__FreeBSD__) +#if HAVE_MMSG +static void uv__udp_sendmmsg(uv_udp_t* handle) { uv_udp_send_t* req; - struct mmsghdr h[20]; - struct mmsghdr* p; - struct uv__queue* q; + struct uv__mmsghdr h[UV__MMSG_MAXWIDTH]; + struct uv__mmsghdr *p; + QUEUE* q; ssize_t npkts; size_t pkts; size_t i; - if (uv__queue_empty(&handle->write_queue)) + if (QUEUE_EMPTY(&handle->write_queue)) return; write_queue_drain: - for (pkts = 0, q = uv__queue_head(&handle->write_queue); - pkts < ARRAY_SIZE(h) && q != &handle->write_queue; - ++pkts, q = uv__queue_head(q)) { + for (pkts = 0, q = QUEUE_HEAD(&handle->write_queue); + pkts < UV__MMSG_MAXWIDTH && q != &handle->write_queue; + ++pkts, q = QUEUE_HEAD(q)) { assert(q != NULL); - req = uv__queue_data(q, uv_udp_send_t, queue); + req = QUEUE_DATA(q, uv_udp_send_t, queue); assert(req != NULL); p = &h[pkts]; @@ -319,22 +355,22 @@ write_queue_drain: } do - npkts = sendmmsg(handle->io_watcher.fd, h, pkts, 0); + npkts = uv__sendmmsg(handle->io_watcher.fd, h, pkts); while (npkts == -1 && errno == EINTR); if (npkts < 1) { if (errno == EAGAIN || errno == EWOULDBLOCK || errno == ENOBUFS) return; - for (i = 0, q = uv__queue_head(&handle->write_queue); + for (i = 0, q = QUEUE_HEAD(&handle->write_queue); i < pkts && q != &handle->write_queue; - ++i, q = uv__queue_head(&handle->write_queue)) { + ++i, q = QUEUE_HEAD(&handle->write_queue)) { assert(q != NULL); - req = uv__queue_data(q, uv_udp_send_t, queue); + req = QUEUE_DATA(q, uv_udp_send_t, queue); assert(req != NULL); req->status = UV__ERR(errno); - uv__queue_remove(&req->queue); - uv__queue_insert_tail(&handle->write_completed_queue, &req->queue); + QUEUE_REMOVE(&req->queue); + QUEUE_INSERT_TAIL(&handle->write_completed_queue, &req->queue); } uv__io_feed(handle->loop, &handle->io_watcher); return; @@ -343,11 +379,11 @@ write_queue_drain: /* Safety: npkts known to be >0 below. Hence cast from ssize_t * to size_t safe. */ - for (i = 0, q = uv__queue_head(&handle->write_queue); + for (i = 0, q = QUEUE_HEAD(&handle->write_queue); i < (size_t)npkts && q != &handle->write_queue; - ++i, q = uv__queue_head(&handle->write_queue)) { + ++i, q = QUEUE_HEAD(&handle->write_queue)) { assert(q != NULL); - req = uv__queue_data(q, uv_udp_send_t, queue); + req = QUEUE_DATA(q, uv_udp_send_t, queue); assert(req != NULL); req->status = req->bufs[0].len; @@ -357,25 +393,37 @@ write_queue_drain: * why we don't handle partial writes. Just pop the request * off the write queue and onto the completed queue, done. */ - uv__queue_remove(&req->queue); - uv__queue_insert_tail(&handle->write_completed_queue, &req->queue); + QUEUE_REMOVE(&req->queue); + QUEUE_INSERT_TAIL(&handle->write_completed_queue, &req->queue); } /* couldn't batch everything, continue sending (jump to avoid stack growth) */ - if (!uv__queue_empty(&handle->write_queue)) + if (!QUEUE_EMPTY(&handle->write_queue)) goto write_queue_drain; uv__io_feed(handle->loop, &handle->io_watcher); -#else /* __linux__ || ____FreeBSD__ */ + return; +} +#endif + +static void uv__udp_sendmsg(uv_udp_t* handle) { uv_udp_send_t* req; struct msghdr h; - struct uv__queue* q; + QUEUE* q; ssize_t size; - while (!uv__queue_empty(&handle->write_queue)) { - q = uv__queue_head(&handle->write_queue); +#if HAVE_MMSG + uv_once(&once, uv__udp_mmsg_init); + if (uv__sendmmsg_avail) { + uv__udp_sendmmsg(handle); + return; + } +#endif + + while (!QUEUE_EMPTY(&handle->write_queue)) { + q = QUEUE_HEAD(&handle->write_queue); assert(q != NULL); - req = uv__queue_data(q, uv_udp_send_t, queue); + req = QUEUE_DATA(q, uv_udp_send_t, queue); assert(req != NULL); memset(&h, 0, sizeof h); @@ -414,11 +462,10 @@ write_queue_drain: * why we don't handle partial writes. Just pop the request * off the write queue and onto the completed queue, done. */ - uv__queue_remove(&req->queue); - uv__queue_insert_tail(&handle->write_completed_queue, &req->queue); + QUEUE_REMOVE(&req->queue); + QUEUE_INSERT_TAIL(&handle->write_completed_queue, &req->queue); uv__io_feed(handle->loop, &handle->io_watcher); } -#endif /* __linux__ || ____FreeBSD__ */ } /* On the BSDs, SO_REUSEPORT implies SO_REUSEADDR but with some additional @@ -448,8 +495,7 @@ static int uv__set_reuse(int fd) { if (setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &yes, sizeof(yes))) return UV__ERR(errno); } -#elif defined(SO_REUSEPORT) && !defined(__linux__) && !defined(__GNU__) && \ - !defined(__sun__) +#elif defined(SO_REUSEPORT) && !defined(__linux__) && !defined(__GNU__) if (setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &yes, sizeof(yes))) return UV__ERR(errno); #else @@ -729,7 +775,7 @@ int uv__udp_send(uv_udp_send_t* req, memcpy(req->bufs, bufs, nbufs * sizeof(bufs[0])); handle->send_queue_size += uv__count_bufs(req->bufs, req->nbufs); handle->send_queue_count++; - uv__queue_insert_tail(&handle->write_queue, &req->queue); + QUEUE_INSERT_TAIL(&handle->write_queue, &req->queue); uv__handle_start(handle); if (empty_queue && !(handle->flags & UV_HANDLE_UDP_PROCESSING)) { @@ -739,7 +785,7 @@ int uv__udp_send(uv_udp_send_t* req, * away. In such cases the `io_watcher` has to be queued for asynchronous * write. */ - if (!uv__queue_empty(&handle->write_queue)) + if (!QUEUE_EMPTY(&handle->write_queue)) uv__io_start(handle->loop, &handle->io_watcher, POLLOUT); } else { uv__io_start(handle->loop, &handle->io_watcher, POLLOUT); @@ -1007,17 +1053,19 @@ int uv__udp_init_ex(uv_loop_t* loop, handle->send_queue_size = 0; handle->send_queue_count = 0; uv__io_init(&handle->io_watcher, uv__udp_io, fd); - uv__queue_init(&handle->write_queue); - uv__queue_init(&handle->write_completed_queue); + QUEUE_INIT(&handle->write_queue); + QUEUE_INIT(&handle->write_completed_queue); return 0; } int uv_udp_using_recvmmsg(const uv_udp_t* handle) { -#if defined(__linux__) || defined(__FreeBSD__) - if (handle->flags & UV_HANDLE_UDP_RECVMMSG) - return 1; +#if HAVE_MMSG + if (handle->flags & UV_HANDLE_UDP_RECVMMSG) { + uv_once(&once, uv__udp_mmsg_init); + return uv__recvmmsg_avail; + } #endif return 0; } diff --git a/src/uv-common.c b/src/uv-common.c index 35581c9..a0a6363 100644 --- a/src/uv-common.c +++ b/src/uv-common.c @@ -128,39 +128,6 @@ int uv_replace_allocator(uv_malloc_func malloc_func, return 0; } - -void uv_os_free_passwd(uv_passwd_t* pwd) { - if (pwd == NULL) - return; - - /* On unix, the memory for name, shell, and homedir are allocated in a single - * uv__malloc() call. The base of the pointer is stored in pwd->username, so - * that is the field that needs to be freed. - */ - uv__free(pwd->username); -#ifdef _WIN32 - uv__free(pwd->homedir); -#endif - pwd->username = NULL; - pwd->shell = NULL; - pwd->homedir = NULL; -} - - -void uv_os_free_group(uv_group_t *grp) { - if (grp == NULL) - return; - - /* The memory for is allocated in a single uv__malloc() call. The base of the - * pointer is stored in grp->members, so that is the only field that needs to - * be freed. - */ - uv__free(grp->members); - grp->members = NULL; - grp->groupname = NULL; -} - - #define XX(uc, lc) case UV_##uc: return sizeof(uv_##lc##_t); size_t uv_handle_size(uv_handle_type type) { @@ -533,17 +500,17 @@ int uv_udp_recv_stop(uv_udp_t* handle) { void uv_walk(uv_loop_t* loop, uv_walk_cb walk_cb, void* arg) { - struct uv__queue queue; - struct uv__queue* q; + QUEUE queue; + QUEUE* q; uv_handle_t* h; - uv__queue_move(&loop->handle_queue, &queue); - while (!uv__queue_empty(&queue)) { - q = uv__queue_head(&queue); - h = uv__queue_data(q, uv_handle_t, handle_queue); + QUEUE_MOVE(&loop->handle_queue, &queue); + while (!QUEUE_EMPTY(&queue)) { + q = QUEUE_HEAD(&queue); + h = QUEUE_DATA(q, uv_handle_t, handle_queue); - uv__queue_remove(q); - uv__queue_insert_tail(&loop->handle_queue, q); + QUEUE_REMOVE(q); + QUEUE_INSERT_TAIL(&loop->handle_queue, q); if (h->flags & UV_HANDLE_INTERNAL) continue; walk_cb(h, arg); @@ -553,17 +520,14 @@ void uv_walk(uv_loop_t* loop, uv_walk_cb walk_cb, void* arg) { static void uv__print_handles(uv_loop_t* loop, int only_active, FILE* stream) { const char* type; - struct uv__queue* q; + QUEUE* q; uv_handle_t* h; if (loop == NULL) loop = uv_default_loop(); - if (stream == NULL) - stream = stderr; - - uv__queue_foreach(q, &loop->handle_queue) { - h = uv__queue_data(q, uv_handle_t, handle_queue); + QUEUE_FOREACH(q, &loop->handle_queue) { + h = QUEUE_DATA(q, uv_handle_t, handle_queue); if (only_active && !uv__is_active(h)) continue; @@ -686,22 +650,14 @@ static unsigned int* uv__get_nbufs(uv_fs_t* req) { void uv__fs_scandir_cleanup(uv_fs_t* req) { uv__dirent_t** dents; - unsigned int* nbufs; - unsigned int i; - unsigned int n; - - if (req->result >= 0) { - dents = req->ptr; - nbufs = uv__get_nbufs(req); - i = 0; - if (*nbufs > 0) - i = *nbufs - 1; + unsigned int* nbufs = uv__get_nbufs(req); - n = (unsigned int) req->result; - for (; i < n; i++) - uv__fs_scandir_free(dents[i]); - } + dents = req->ptr; + if (*nbufs > 0 && *nbufs != (unsigned int) req->result) + (*nbufs)--; + for (; *nbufs < (unsigned int) req->result; (*nbufs)++) + uv__fs_scandir_free(dents[*nbufs]); uv__fs_scandir_free(req->ptr); req->ptr = NULL; @@ -850,7 +806,7 @@ uv_loop_t* uv_loop_new(void) { void on_uv_loop_close(uv_loop_t* loop); int uv_loop_close(uv_loop_t* loop) { - struct uv__queue* q; + QUEUE* q; uv_handle_t* h; #ifndef NDEBUG void* saved_data; @@ -859,8 +815,8 @@ int uv_loop_close(uv_loop_t* loop) { if (uv__has_active_reqs(loop)) return UV_EBUSY; - uv__queue_foreach(q, &loop->handle_queue) { - h = uv__queue_data(q, uv_handle_t, handle_queue); + QUEUE_FOREACH(q, &loop->handle_queue) { + h = QUEUE_DATA(q, uv_handle_t, handle_queue); if (!(h->flags & UV_HANDLE_INTERNAL)) return UV_EBUSY; } @@ -925,17 +881,12 @@ void uv_os_free_environ(uv_env_item_t* envitems, int count) { void uv_free_cpu_info(uv_cpu_info_t* cpu_infos, int count) { -#ifdef __linux__ - (void) &count; - uv__free(cpu_infos); -#else int i; for (i = 0; i < count; i++) uv__free(cpu_infos[i].model); uv__free(cpu_infos); -#endif /* __linux__ */ } @@ -949,7 +900,7 @@ __attribute__((destructor)) void uv_library_shutdown(void) { static int was_shutdown; - if (uv__exchange_int_relaxed(&was_shutdown, 1)) + if (uv__load_relaxed(&was_shutdown)) return; uv__process_title_cleanup(); @@ -960,6 +911,7 @@ void uv_library_shutdown(void) { #else uv__threadpool_cleanup(); #endif + uv__store_relaxed(&was_shutdown, 1); } @@ -1005,15 +957,6 @@ void uv__metrics_set_provider_entry_time(uv_loop_t* loop) { } -int uv_metrics_info(uv_loop_t* loop, uv_metrics_t* metrics) { - memcpy(metrics, - &uv__get_loop_metrics(loop)->metrics, - sizeof(*metrics)); - - return 0; -} - - uint64_t uv_metrics_idle_time(uv_loop_t* loop) { uv__loop_metrics_t* loop_metrics; uint64_t entry_time; @@ -1030,7 +973,6 @@ uint64_t uv_metrics_idle_time(uv_loop_t* loop) { return idle_time; } - uint64_t uv__get_addr_tag(void* addr) { uint64_t tag = 0; diff --git a/src/uv-common.h b/src/uv-common.h index bcff87a..8077a4a 100644 --- a/src/uv-common.h +++ b/src/uv-common.h @@ -30,17 +30,18 @@ #include #include #include -#include + +#if defined(_MSC_VER) && _MSC_VER < 1600 +# include "uv/stdint-msvc2008.h" +#else +# include +#endif #include "uv.h" #include "uv/tree.h" #include "queue.h" #include "strscpy.h" -#ifndef _MSC_VER -# include -#endif - #if EDOM > 0 # define UV__ERR(x) (-(x)) #else @@ -52,25 +53,19 @@ extern int snprintf(char*, size_t, const char*, ...); #endif #define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0])) -#define ARRAY_END(a) ((a) + ARRAY_SIZE(a)) #define container_of(ptr, type, member) \ ((type *) ((char *) (ptr) - offsetof(type, member))) -/* C11 defines static_assert to be a macro which calls _Static_assert. */ -#if defined(static_assert) -#define STATIC_ASSERT(expr) static_assert(expr, #expr) -#else #define STATIC_ASSERT(expr) \ void uv__static_assert(int static_assert_failed[1 - 2 * !(expr)]) -#endif -#ifdef _MSC_VER -#define uv__exchange_int_relaxed(p, v) \ - InterlockedExchangeNoFence((LONG volatile*)(p), v) +#if defined(__GNUC__) && (__GNUC__ > 4 || __GNUC__ == 4 && __GNUC_MINOR__ >= 7) +#define uv__load_relaxed(p) __atomic_load_n(p, __ATOMIC_RELAXED) +#define uv__store_relaxed(p, v) __atomic_store_n(p, v, __ATOMIC_RELAXED) #else -#define uv__exchange_int_relaxed(p, v) \ - atomic_exchange_explicit((_Atomic int*)(p), v, memory_order_relaxed) +#define uv__load_relaxed(p) (*p) +#define uv__store_relaxed(p, v) do *p = v; while (0) #endif #define UV__UDP_DGRAM_MAXSIZE (64 * 1024) @@ -88,6 +83,7 @@ enum { /* Used by streams. */ UV_HANDLE_LISTENING = 0x00000040, UV_HANDLE_CONNECTION = 0x00000080, + UV_HANDLE_SHUTTING = 0x00000100, UV_HANDLE_SHUT = 0x00000200, UV_HANDLE_READ_PARTIAL = 0x00000400, UV_HANDLE_READ_EOF = 0x00000800, @@ -270,14 +266,6 @@ void uv__threadpool_cleanup(void); #define uv__is_closing(h) \ (((h)->flags & (UV_HANDLE_CLOSING | UV_HANDLE_CLOSED)) != 0) -#if defined(_WIN32) -# define uv__is_stream_shutting(h) \ - (h->stream.conn.shutdown_req != NULL) -#else -# define uv__is_stream_shutting(h) \ - (h->shutdown_req != NULL) -#endif - #define uv__handle_start(h) \ do { \ if (((h)->flags & UV_HANDLE_ACTIVE) != 0) break; \ @@ -326,7 +314,7 @@ void uv__threadpool_cleanup(void); (h)->loop = (loop_); \ (h)->type = (type_); \ (h)->flags = UV_HANDLE_REF; /* Ref the loop when active. */ \ - uv__queue_insert_tail(&(loop_)->handle_queue, &(h)->handle_queue); \ + QUEUE_INSERT_TAIL(&(loop_)->handle_queue, &(h)->handle_queue); \ uv__handle_platform_init(h); \ } \ while (0) @@ -362,21 +350,6 @@ void uv__threadpool_cleanup(void); #define uv__get_loop_metrics(loop) \ (&uv__get_internal_fields(loop)->loop_metrics) -#define uv__metrics_inc_loop_count(loop) \ - do { \ - uv__get_loop_metrics(loop)->metrics.loop_count++; \ - } while (0) - -#define uv__metrics_inc_events(loop, e) \ - do { \ - uv__get_loop_metrics(loop)->metrics.events += (e); \ - } while (0) - -#define uv__metrics_inc_events_waiting(loop, e) \ - do { \ - uv__get_loop_metrics(loop)->metrics.events_waiting += (e); \ - } while (0) - /* Allocator prototypes */ void *uv__calloc(size_t count, size_t size); char *uv__strdup(const char* s); @@ -390,7 +363,6 @@ typedef struct uv__loop_metrics_s uv__loop_metrics_t; typedef struct uv__loop_internal_fields_s uv__loop_internal_fields_t; struct uv__loop_metrics_s { - uv_metrics_t metrics; uint64_t provider_entry_time; uint64_t provider_idle_time; uv_mutex_t lock; @@ -399,43 +371,13 @@ struct uv__loop_metrics_s { void uv__metrics_update_idle_time(uv_loop_t* loop); void uv__metrics_set_provider_entry_time(uv_loop_t* loop); -#ifdef __linux__ -struct uv__iou { - uint32_t* sqhead; - uint32_t* sqtail; - uint32_t* sqarray; - uint32_t sqmask; - uint32_t* sqflags; - uint32_t* cqhead; - uint32_t* cqtail; - uint32_t cqmask; - void* sq; /* pointer to munmap() on event loop teardown */ - void* cqe; /* pointer to array of struct uv__io_uring_cqe */ - void* sqe; /* pointer to array of struct uv__io_uring_sqe */ - size_t sqlen; - size_t cqlen; - size_t maxlen; - size_t sqelen; - int ringfd; - uint32_t in_flight; - uint32_t flags; -}; -#endif /* __linux__ */ - struct uv__loop_internal_fields_s { unsigned int flags; uv__loop_metrics_t loop_metrics; - int current_timeout; -#ifdef __linux__ - struct uv__iou ctl; - struct uv__iou iou; - void* inv; /* used by uv__platform_invalidate_fd() */ -#endif /* __linux__ */ #ifdef USE_FFRT - struct uv__queue wq_sub[4]; + void* wq_sub[4][2]; #endif }; uint64_t uv__get_addr_tag(void* addr); - #endif /* UV_COMMON_H_ */ diff --git a/src/win/core.c b/src/win/core.c index 3af17e6..98a04c0 100644 --- a/src/win/core.c +++ b/src/win/core.c @@ -245,9 +245,6 @@ int uv_loop_init(uv_loop_t* loop) { err = uv_mutex_init(&lfields->loop_metrics.lock); if (err) goto fail_metrics_mutex_init; - memset(&lfields->loop_metrics.metrics, - 0, - sizeof(lfields->loop_metrics.metrics)); /* To prevent uninitialized memory access, loop->time must be initialized * to zero before calling uv_update_time for the first time. @@ -255,8 +252,8 @@ int uv_loop_init(uv_loop_t* loop) { loop->time = 0; uv_update_time(loop); - uv__queue_init(&loop->wq); - uv__queue_init(&loop->handle_queue); + QUEUE_INIT(&loop->wq); + QUEUE_INIT(&loop->handle_queue); loop->active_reqs.count = 0; loop->active_handles = 0; @@ -282,6 +279,9 @@ int uv_loop_init(uv_loop_t* loop) { memset(&loop->poll_peer_sockets, 0, sizeof loop->poll_peer_sockets); + loop->active_tcp_streams = 0; + loop->active_udp_streams = 0; + loop->timer_counter = 0; loop->stop_flag = 0; @@ -359,7 +359,7 @@ void uv__loop_close(uv_loop_t* loop) { } uv_mutex_lock(&loop->wq_mutex); - assert(uv__queue_empty(&loop->wq) && "thread pool work queue not empty!"); + assert(QUEUE_EMPTY(&loop->wq) && "thread pool work queue not empty!"); assert(!uv__has_active_reqs(loop)); uv_mutex_unlock(&loop->wq_mutex); uv_mutex_destroy(&loop->wq_mutex); @@ -426,7 +426,6 @@ int uv_backend_timeout(const uv_loop_t* loop) { static void uv__poll_wine(uv_loop_t* loop, DWORD timeout) { - uv__loop_internal_fields_t* lfields; DWORD bytes; ULONG_PTR key; OVERLAPPED* overlapped; @@ -436,10 +435,9 @@ static void uv__poll_wine(uv_loop_t* loop, DWORD timeout) { uint64_t user_timeout; int reset_timeout; - lfields = uv__get_internal_fields(loop); timeout_time = loop->time + timeout; - if (lfields->flags & UV_METRICS_IDLE_TIME) { + if (uv__get_internal_fields(loop)->flags & UV_METRICS_IDLE_TIME) { reset_timeout = 1; user_timeout = timeout; timeout = 0; @@ -454,12 +452,6 @@ static void uv__poll_wine(uv_loop_t* loop, DWORD timeout) { if (timeout != 0) uv__metrics_set_provider_entry_time(loop); - /* Store the current timeout in a location that's globally accessible so - * other locations like uv__work_done() can determine whether the queue - * of events in the callback were waiting when poll was called. - */ - lfields->current_timeout = timeout; - GetQueuedCompletionStatus(loop->iocp, &bytes, &key, @@ -467,8 +459,6 @@ static void uv__poll_wine(uv_loop_t* loop, DWORD timeout) { timeout); if (reset_timeout != 0) { - if (overlapped && timeout == 0) - uv__metrics_inc_events_waiting(loop, 1); timeout = user_timeout; reset_timeout = 0; } @@ -481,8 +471,6 @@ static void uv__poll_wine(uv_loop_t* loop, DWORD timeout) { uv__metrics_update_idle_time(loop); if (overlapped) { - uv__metrics_inc_events(loop, 1); - /* Package was dequeued */ req = uv__overlapped_to_req(overlapped); uv__insert_pending_req(loop, req); @@ -517,7 +505,6 @@ static void uv__poll_wine(uv_loop_t* loop, DWORD timeout) { static void uv__poll(uv_loop_t* loop, DWORD timeout) { - uv__loop_internal_fields_t* lfields; BOOL success; uv_req_t* req; OVERLAPPED_ENTRY overlappeds[128]; @@ -526,13 +513,11 @@ static void uv__poll(uv_loop_t* loop, DWORD timeout) { int repeat; uint64_t timeout_time; uint64_t user_timeout; - uint64_t actual_timeout; int reset_timeout; - lfields = uv__get_internal_fields(loop); timeout_time = loop->time + timeout; - if (lfields->flags & UV_METRICS_IDLE_TIME) { + if (uv__get_internal_fields(loop)->flags & UV_METRICS_IDLE_TIME) { reset_timeout = 1; user_timeout = timeout; timeout = 0; @@ -541,20 +526,12 @@ static void uv__poll(uv_loop_t* loop, DWORD timeout) { } for (repeat = 0; ; repeat++) { - actual_timeout = timeout; - /* Only need to set the provider_entry_time if timeout != 0. The function * will return early if the loop isn't configured with UV_METRICS_IDLE_TIME. */ if (timeout != 0) uv__metrics_set_provider_entry_time(loop); - /* Store the current timeout in a location that's globally accessible so - * other locations like uv__work_done() can determine whether the queue - * of events in the callback were waiting when poll was called. - */ - lfields->current_timeout = timeout; - success = pGetQueuedCompletionStatusEx(loop->iocp, overlappeds, ARRAY_SIZE(overlappeds), @@ -568,9 +545,9 @@ static void uv__poll(uv_loop_t* loop, DWORD timeout) { } /* Placed here because on success the loop will break whether there is an - * empty package or not, or if pGetQueuedCompletionStatusEx returned early - * then the timeout will be updated and the loop will run again. In either - * case the idle time will need to be updated. + * empty package or not, or if GetQueuedCompletionStatus returned early then + * the timeout will be updated and the loop will run again. In either case + * the idle time will need to be updated. */ uv__metrics_update_idle_time(loop); @@ -580,10 +557,6 @@ static void uv__poll(uv_loop_t* loop, DWORD timeout) { * meant only to wake us up. */ if (overlappeds[i].lpOverlapped) { - uv__metrics_inc_events(loop, 1); - if (actual_timeout == 0) - uv__metrics_inc_events_waiting(loop, 1); - req = uv__overlapped_to_req(overlappeds[i].lpOverlapped); uv__insert_pending_req(loop, req); } @@ -627,16 +600,10 @@ int uv_run(uv_loop_t *loop, uv_run_mode mode) { if (!r) uv_update_time(loop); - /* Maintain backwards compatibility by processing timers before entering the - * while loop for UV_RUN_DEFAULT. Otherwise timers only need to be executed - * once, which should be done after polling in order to maintain proper - * execution order of the conceptual event loop. */ - if (mode == UV_RUN_DEFAULT && r != 0 && loop->stop_flag == 0) { + while (r != 0 && loop->stop_flag == 0) { uv_update_time(loop); uv__run_timers(loop); - } - while (r != 0 && loop->stop_flag == 0) { can_sleep = loop->pending_reqs_tail == NULL && loop->idle_handles == NULL; uv__process_reqs(loop); @@ -647,8 +614,6 @@ int uv_run(uv_loop_t *loop, uv_run_mode mode) { if ((mode == UV_RUN_ONCE && can_sleep) || mode == UV_RUN_DEFAULT) timeout = uv_backend_timeout(loop); - uv__metrics_inc_loop_count(loop); - if (pGetQueuedCompletionStatusEx) uv__poll(loop, timeout); else @@ -669,8 +634,18 @@ int uv_run(uv_loop_t *loop, uv_run_mode mode) { uv__check_invoke(loop); uv__process_endgames(loop); - uv_update_time(loop); - uv__run_timers(loop); + if (mode == UV_RUN_ONCE) { + /* UV_RUN_ONCE implies forward progress: at least one callback must have + * been invoked when it returns. uv__io_poll() can return without doing + * I/O (meaning: no callbacks) when its timeout expires - which means we + * have pending timers that satisfy the forward progress constraint. + * + * UV_RUN_NOWAIT makes no guarantees about progress so it's omitted from + * the check. + */ + uv_update_time(loop); + uv__run_timers(loop); + } r = uv__loop_alive(loop); if (mode == UV_RUN_ONCE || mode == UV_RUN_NOWAIT) diff --git a/src/win/dl.c b/src/win/dl.c index 7880c95..676be4d 100644 --- a/src/win/dl.c +++ b/src/win/dl.c @@ -27,17 +27,18 @@ static int uv__dlerror(uv_lib_t* lib, const char* filename, DWORD errorno); int uv_dlopen(const char* filename, uv_lib_t* lib) { WCHAR filename_w[32768]; - ssize_t r; lib->handle = NULL; lib->errmsg = NULL; - r = uv_wtf8_length_as_utf16(filename); - if (r < 0) - return uv__dlerror(lib, filename, ERROR_NO_UNICODE_TRANSLATION); - if ((size_t) r > ARRAY_SIZE(filename_w)) - return uv__dlerror(lib, filename, ERROR_INSUFFICIENT_BUFFER); - uv_wtf8_to_utf16(filename, filename_w, r); + if (!MultiByteToWideChar(CP_UTF8, + 0, + filename, + -1, + filename_w, + ARRAY_SIZE(filename_w))) { + return uv__dlerror(lib, filename, GetLastError()); + } lib->handle = LoadLibraryExW(filename_w, NULL, LOAD_WITH_ALTERED_SEARCH_PATH); if (lib->handle == NULL) { diff --git a/src/win/fs-event.c b/src/win/fs-event.c index fce4118..6758c7c 100644 --- a/src/win/fs-event.c +++ b/src/win/fs-event.c @@ -114,7 +114,7 @@ static int uv__split_path(const WCHAR* filename, WCHAR** dir, } } - *file = _wcsdup(filename); + *file = wcsdup(filename); } else { if (dir) { *dir = (WCHAR*)uv__malloc((i + 2) * sizeof(WCHAR)); @@ -157,8 +157,7 @@ int uv_fs_event_start(uv_fs_event_t* handle, uv_fs_event_cb cb, const char* path, unsigned int flags) { - int is_path_dir; - size_t size; + int name_size, is_path_dir, size; DWORD attr, last_error; WCHAR* dir = NULL, *dir_to_watch, *pathw = NULL; DWORD short_path_buffer_len; @@ -177,9 +176,23 @@ int uv_fs_event_start(uv_fs_event_t* handle, uv__handle_start(handle); - last_error = uv__convert_utf8_to_utf16(path, &pathw); - if (last_error) - goto error_uv; + /* Convert name to UTF16. */ + + name_size = MultiByteToWideChar(CP_UTF8, 0, path, -1, NULL, 0) * + sizeof(WCHAR); + pathw = (WCHAR*)uv__malloc(name_size); + if (!pathw) { + uv_fatal_error(ERROR_OUTOFMEMORY, "uv__malloc"); + } + + if (!MultiByteToWideChar(CP_UTF8, + 0, + path, + -1, + pathw, + name_size / sizeof(WCHAR))) { + return uv_translate_sys_error(GetLastError()); + } /* Determine whether path is a file or a directory. */ attr = GetFileAttributesW(pathw); @@ -320,9 +333,6 @@ short_path_done: return 0; error: - last_error = uv_translate_sys_error(last_error); - -error_uv: if (handle->path) { uv__free(handle->path); handle->path = NULL; @@ -355,7 +365,7 @@ error_uv: uv__free(short_path); - return last_error; + return uv_translate_sys_error(last_error); } diff --git a/src/win/fs.c b/src/win/fs.c index b73c17d..7923079 100644 --- a/src/win/fs.c +++ b/src/win/fs.c @@ -31,11 +31,6 @@ #include #include "uv.h" - -/* requires , included via "uv.h" above, but needs to - be included before our "winapi.h", included via "internal.h" below. */ -#include - #include "internal.h" #include "req-inl.h" #include "handle-inl.h" @@ -147,9 +142,172 @@ void uv__fs_init(void) { } -INLINE static int fs__readlink_handle(HANDLE handle, - char** target_ptr, - size_t* target_len_ptr) { +INLINE static int fs__capture_path(uv_fs_t* req, const char* path, + const char* new_path, const int copy_path) { + char* buf; + char* pos; + ssize_t buf_sz = 0, path_len = 0, pathw_len = 0, new_pathw_len = 0; + + /* new_path can only be set if path is also set. */ + assert(new_path == NULL || path != NULL); + + if (path != NULL) { + pathw_len = MultiByteToWideChar(CP_UTF8, + 0, + path, + -1, + NULL, + 0); + if (pathw_len == 0) { + return GetLastError(); + } + + buf_sz += pathw_len * sizeof(WCHAR); + } + + if (path != NULL && copy_path) { + path_len = 1 + strlen(path); + buf_sz += path_len; + } + + if (new_path != NULL) { + new_pathw_len = MultiByteToWideChar(CP_UTF8, + 0, + new_path, + -1, + NULL, + 0); + if (new_pathw_len == 0) { + return GetLastError(); + } + + buf_sz += new_pathw_len * sizeof(WCHAR); + } + + + if (buf_sz == 0) { + req->file.pathw = NULL; + req->fs.info.new_pathw = NULL; + req->path = NULL; + return 0; + } + + buf = (char*) uv__malloc(buf_sz); + if (buf == NULL) { + return ERROR_OUTOFMEMORY; + } + + pos = buf; + + if (path != NULL) { + DWORD r = MultiByteToWideChar(CP_UTF8, + 0, + path, + -1, + (WCHAR*) pos, + pathw_len); + assert(r == (DWORD) pathw_len); + req->file.pathw = (WCHAR*) pos; + pos += r * sizeof(WCHAR); + } else { + req->file.pathw = NULL; + } + + if (new_path != NULL) { + DWORD r = MultiByteToWideChar(CP_UTF8, + 0, + new_path, + -1, + (WCHAR*) pos, + new_pathw_len); + assert(r == (DWORD) new_pathw_len); + req->fs.info.new_pathw = (WCHAR*) pos; + pos += r * sizeof(WCHAR); + } else { + req->fs.info.new_pathw = NULL; + } + + req->path = path; + if (path != NULL && copy_path) { + memcpy(pos, path, path_len); + assert(path_len == buf_sz - (pos - buf)); + req->path = pos; + } + + req->flags |= UV_FS_FREE_PATHS; + + return 0; +} + + + +INLINE static void uv__fs_req_init(uv_loop_t* loop, uv_fs_t* req, + uv_fs_type fs_type, const uv_fs_cb cb) { + uv__once_init(); + UV_REQ_INIT(req, UV_FS); + req->loop = loop; + req->flags = 0; + req->fs_type = fs_type; + req->sys_errno_ = 0; + req->result = 0; + req->ptr = NULL; + req->path = NULL; + req->cb = cb; + memset(&req->fs, 0, sizeof(req->fs)); +} + + +static int fs__wide_to_utf8(WCHAR* w_source_ptr, + DWORD w_source_len, + char** target_ptr, + uint64_t* target_len_ptr) { + int r; + int target_len; + char* target; + target_len = WideCharToMultiByte(CP_UTF8, + 0, + w_source_ptr, + w_source_len, + NULL, + 0, + NULL, + NULL); + + if (target_len == 0) { + return -1; + } + + if (target_len_ptr != NULL) { + *target_len_ptr = target_len; + } + + if (target_ptr == NULL) { + return 0; + } + + target = uv__malloc(target_len + 1); + if (target == NULL) { + SetLastError(ERROR_OUTOFMEMORY); + return -1; + } + + r = WideCharToMultiByte(CP_UTF8, + 0, + w_source_ptr, + w_source_len, + target, + target_len, + NULL, + NULL); + assert(r == target_len); + target[target_len] = '\0'; + *target_ptr = target; + return 0; +} + + +INLINE static int fs__readlink_handle(HANDLE handle, char** target_ptr, + uint64_t* target_len_ptr) { char buffer[MAXIMUM_REPARSE_DATA_BUFFER_SIZE]; REPARSE_DATA_BUFFER* reparse_data = (REPARSE_DATA_BUFFER*) buffer; WCHAR* w_target; @@ -279,99 +437,7 @@ INLINE static int fs__readlink_handle(HANDLE handle, return -1; } - assert(target_ptr == NULL || *target_ptr == NULL); - return uv_utf16_to_wtf8(w_target, w_target_len, target_ptr, target_len_ptr); -} - - -INLINE static int fs__capture_path(uv_fs_t* req, const char* path, - const char* new_path, const int copy_path) { - WCHAR* buf; - WCHAR* pos; - size_t buf_sz = 0; - size_t path_len = 0; - ssize_t pathw_len = 0; - ssize_t new_pathw_len = 0; - - /* new_path can only be set if path is also set. */ - assert(new_path == NULL || path != NULL); - - if (path != NULL) { - pathw_len = uv_wtf8_length_as_utf16(path); - if (pathw_len < 0) - return ERROR_INVALID_NAME; - buf_sz += pathw_len * sizeof(WCHAR); - } - - if (path != NULL && copy_path) { - path_len = 1 + strlen(path); - buf_sz += path_len; - } - - if (new_path != NULL) { - new_pathw_len = uv_wtf8_length_as_utf16(new_path); - if (new_pathw_len < 0) - return ERROR_INVALID_NAME; - buf_sz += new_pathw_len * sizeof(WCHAR); - } - - - if (buf_sz == 0) { - req->file.pathw = NULL; - req->fs.info.new_pathw = NULL; - req->path = NULL; - return 0; - } - - buf = uv__malloc(buf_sz); - if (buf == NULL) { - return ERROR_OUTOFMEMORY; - } - - pos = buf; - - if (path != NULL) { - uv_wtf8_to_utf16(path, pos, pathw_len); - req->file.pathw = pos; - pos += pathw_len; - } else { - req->file.pathw = NULL; - } - - if (new_path != NULL) { - uv_wtf8_to_utf16(new_path, pos, new_pathw_len); - req->fs.info.new_pathw = pos; - pos += new_pathw_len; - } else { - req->fs.info.new_pathw = NULL; - } - - req->path = path; - if (path != NULL && copy_path) { - memcpy(pos, path, path_len); - assert(path_len == buf_sz - (pos - buf) * sizeof(WCHAR)); - req->path = (char*) pos; - } - - req->flags |= UV_FS_FREE_PATHS; - - return 0; -} - - -INLINE static void uv__fs_req_init(uv_loop_t* loop, uv_fs_t* req, - uv_fs_type fs_type, const uv_fs_cb cb) { - uv__once_init(); - UV_REQ_INIT(req, UV_FS); - req->loop = loop; - req->flags = 0; - req->fs_type = fs_type; - req->sys_errno_ = 0; - req->result = 0; - req->ptr = NULL; - req->path = NULL; - req->cb = cb; - memset(&req->fs, 0, sizeof(req->fs)); + return fs__wide_to_utf8(w_target, w_target_len, target_ptr, target_len_ptr); } @@ -407,8 +473,8 @@ void fs__open(uv_fs_t* req) { /* Obtain the active umask. umask() never fails and returns the previous * umask. */ - current_umask = _umask(0); - _umask(current_umask); + current_umask = umask(0); + umask(current_umask); /* convert flags and mode to CreateFile parameters */ switch (flags & (UV_FS_O_RDONLY | UV_FS_O_WRONLY | UV_FS_O_RDWR)) { @@ -1361,8 +1427,7 @@ void fs__scandir(uv_fs_t* req) { uv__dirent_t* dirent; size_t wchar_len; - size_t wtf8_len; - char* wtf8; + size_t utf8_len; /* Obtain a pointer to the current directory entry. */ position += next_entry_offset; @@ -1389,8 +1454,11 @@ void fs__scandir(uv_fs_t* req) { info->FileName[1] == L'.') continue; - /* Compute the space required to store the filename as WTF-8. */ - wtf8_len = uv_utf16_length_as_wtf8(&info->FileName[0], wchar_len); + /* Compute the space required to store the filename as UTF-8. */ + utf8_len = WideCharToMultiByte( + CP_UTF8, 0, &info->FileName[0], wchar_len, NULL, 0, NULL, NULL); + if (utf8_len == 0) + goto win32_error; /* Resize the dirent array if needed. */ if (dirents_used >= dirents_size) { @@ -1410,16 +1478,25 @@ void fs__scandir(uv_fs_t* req) { * includes room for the first character of the filename, but `utf8_len` * doesn't count the NULL terminator at this point. */ - dirent = uv__malloc(sizeof *dirent + wtf8_len); + dirent = uv__malloc(sizeof *dirent + utf8_len); if (dirent == NULL) goto out_of_memory_error; dirents[dirents_used++] = dirent; /* Convert file name to UTF-8. */ - wtf8 = &dirent->d_name[0]; - if (uv_utf16_to_wtf8(&info->FileName[0], wchar_len, &wtf8, &wtf8_len) != 0) - goto out_of_memory_error; + if (WideCharToMultiByte(CP_UTF8, + 0, + &info->FileName[0], + wchar_len, + &dirent->d_name[0], + utf8_len, + NULL, + NULL) == 0) + goto win32_error; + + /* Add a null terminator to the filename. */ + dirent->d_name[utf8_len] = '\0'; /* Fill out the type field. */ if (info->FileAttributes & FILE_ATTRIBUTE_DEVICE) @@ -1629,37 +1706,11 @@ void fs__closedir(uv_fs_t* req) { INLINE static int fs__stat_handle(HANDLE handle, uv_stat_t* statbuf, int do_lstat) { - size_t target_length = 0; - FILE_FS_DEVICE_INFORMATION device_info; FILE_ALL_INFORMATION file_info; FILE_FS_VOLUME_INFORMATION volume_info; NTSTATUS nt_status; IO_STATUS_BLOCK io_status; - nt_status = pNtQueryVolumeInformationFile(handle, - &io_status, - &device_info, - sizeof device_info, - FileFsDeviceInformation); - - /* Buffer overflow (a warning status code) is expected here. */ - if (NT_ERROR(nt_status)) { - SetLastError(pRtlNtStatusToDosError(nt_status)); - return -1; - } - - /* If it's NUL device set fields as reasonable as possible and return. */ - if (device_info.DeviceType == FILE_DEVICE_NULL) { - memset(statbuf, 0, sizeof(uv_stat_t)); - statbuf->st_mode = _S_IFCHR; - statbuf->st_mode |= (_S_IREAD | _S_IWRITE) | ((_S_IREAD | _S_IWRITE) >> 3) | - ((_S_IREAD | _S_IWRITE) >> 6); - statbuf->st_nlink = 1; - statbuf->st_blksize = 4096; - statbuf->st_rdev = FILE_DEVICE_NULL << 16; - return 0; - } - nt_status = pNtQueryInformationFile(handle, &io_status, &file_info, @@ -1725,10 +1776,9 @@ INLINE static int fs__stat_handle(HANDLE handle, uv_stat_t* statbuf, * to be treated as a regular file. The higher level lstat function will * detect this failure and retry without do_lstat if appropriate. */ - if (fs__readlink_handle(handle, NULL, &target_length) != 0) + if (fs__readlink_handle(handle, NULL, &statbuf->st_size) != 0) return -1; statbuf->st_mode |= S_IFLNK; - statbuf->st_size = target_length; } if (statbuf->st_mode == 0) { @@ -1865,37 +1915,6 @@ INLINE static void fs__stat_impl(uv_fs_t* req, int do_lstat) { } -INLINE static int fs__fstat_handle(int fd, HANDLE handle, uv_stat_t* statbuf) { - DWORD file_type; - - /* Each file type is processed differently. */ - file_type = uv_guess_handle(fd); - switch (file_type) { - /* Disk files use the existing logic from fs__stat_handle. */ - case UV_FILE: - return fs__stat_handle(handle, statbuf, 0); - - /* Devices and pipes are processed identically. There is no more information - * for them from any API. Fields are set as reasonably as possible and the - * function returns. */ - case UV_TTY: - case UV_NAMED_PIPE: - memset(statbuf, 0, sizeof(uv_stat_t)); - statbuf->st_mode = file_type == UV_TTY ? _S_IFCHR : _S_IFIFO; - statbuf->st_nlink = 1; - statbuf->st_rdev = (file_type == UV_TTY ? FILE_DEVICE_CONSOLE : FILE_DEVICE_NAMED_PIPE) << 16; - statbuf->st_ino = (uintptr_t) handle; - return 0; - - /* If file type is unknown it is an error. */ - case UV_UNKNOWN_HANDLE: - default: - SetLastError(ERROR_INVALID_HANDLE); - return -1; - } -} - - static void fs__stat(uv_fs_t* req) { fs__stat_prepare_path(req->file.pathw); fs__stat_impl(req, 0); @@ -1921,7 +1940,7 @@ static void fs__fstat(uv_fs_t* req) { return; } - if (fs__fstat_handle(fd, handle, &req->statbuf) != 0) { + if (fs__stat_handle(handle, &req->statbuf, 0) != 0) { SET_REQ_WIN32_ERROR(req, GetLastError()); return; } @@ -2202,7 +2221,7 @@ static void fs__fchmod(uv_fs_t* req) { SET_REQ_WIN32_ERROR(req, pRtlNtStatusToDosError(nt_status)); goto fchmod_cleanup; } - /* Remember to clear the flag later on */ + /* Remeber to clear the flag later on */ clear_archive_flag = 1; } else { clear_archive_flag = 0; @@ -2584,12 +2603,8 @@ static void fs__readlink(uv_fs_t* req) { return; } - assert(req->ptr == NULL); if (fs__readlink_handle(handle, (char**) &req->ptr, NULL) != 0) { - DWORD error = GetLastError(); - SET_REQ_WIN32_ERROR(req, error); - if (error == ERROR_NOT_A_REPARSE_POINT) - req->result = UV_EINVAL; + SET_REQ_WIN32_ERROR(req, GetLastError()); CloseHandle(handle); return; } @@ -2644,8 +2659,7 @@ static ssize_t fs__realpath_handle(HANDLE handle, char** realpath_ptr) { return -1; } - assert(*realpath_ptr == NULL); - r = uv_utf16_to_wtf8(w_realpath_ptr, w_realpath_len, realpath_ptr, NULL); + r = fs__wide_to_utf8(w_realpath_ptr, w_realpath_len, realpath_ptr, NULL); uv__free(w_realpath_buf); return r; } @@ -2665,7 +2679,6 @@ static void fs__realpath(uv_fs_t* req) { return; } - assert(req->ptr == NULL); if (fs__realpath_handle(handle, (char**) &req->ptr) == -1) { CloseHandle(handle); SET_REQ_WIN32_ERROR(req, GetLastError()); diff --git a/src/win/getaddrinfo.c b/src/win/getaddrinfo.c index 8b8406a..dfab860 100644 --- a/src/win/getaddrinfo.c +++ b/src/win/getaddrinfo.c @@ -104,14 +104,13 @@ static void uv__getaddrinfo_work(struct uv__work* w) { */ static void uv__getaddrinfo_done(struct uv__work* w, int status) { uv_getaddrinfo_t* req; - size_t addrinfo_len = 0; - ssize_t name_len = 0; + int addrinfo_len = 0; + int name_len = 0; size_t addrinfo_struct_len = ALIGNED_SIZE(sizeof(struct addrinfo)); struct addrinfoW* addrinfow_ptr; struct addrinfo* addrinfo_ptr; char* alloc_ptr = NULL; char* cur_ptr = NULL; - int r; req = container_of(w, uv_getaddrinfo_t, work_req); @@ -132,12 +131,19 @@ static void uv__getaddrinfo_done(struct uv__work* w, int status) { addrinfo_len += addrinfo_struct_len + ALIGNED_SIZE(addrinfow_ptr->ai_addrlen); if (addrinfow_ptr->ai_canonname != NULL) { - name_len = uv_utf16_length_as_wtf8(addrinfow_ptr->ai_canonname, -1); - if (name_len < 0) { - req->retcode = name_len; + name_len = WideCharToMultiByte(CP_UTF8, + 0, + addrinfow_ptr->ai_canonname, + -1, + NULL, + 0, + NULL, + NULL); + if (name_len == 0) { + req->retcode = uv_translate_sys_error(GetLastError()); goto complete; } - addrinfo_len += ALIGNED_SIZE(name_len + 1); + addrinfo_len += ALIGNED_SIZE(name_len); } addrinfow_ptr = addrinfow_ptr->ai_next; } @@ -176,14 +182,27 @@ static void uv__getaddrinfo_done(struct uv__work* w, int status) { /* convert canonical name to UTF-8 */ if (addrinfow_ptr->ai_canonname != NULL) { - name_len = alloc_ptr + addrinfo_len - cur_ptr; - r = uv__copy_utf16_to_utf8(addrinfow_ptr->ai_canonname, - -1, - cur_ptr, - (size_t*)&name_len); - assert(r == 0); + name_len = WideCharToMultiByte(CP_UTF8, + 0, + addrinfow_ptr->ai_canonname, + -1, + NULL, + 0, + NULL, + NULL); + assert(name_len > 0); + assert(cur_ptr + name_len <= alloc_ptr + addrinfo_len); + name_len = WideCharToMultiByte(CP_UTF8, + 0, + addrinfow_ptr->ai_canonname, + -1, + cur_ptr, + name_len, + NULL, + NULL); + assert(name_len > 0); addrinfo_ptr->ai_canonname = cur_ptr; - cur_ptr += ALIGNED_SIZE(name_len + 1); + cur_ptr += ALIGNED_SIZE(name_len); } assert(cur_ptr <= alloc_ptr + addrinfo_len); @@ -242,11 +261,12 @@ int uv_getaddrinfo(uv_loop_t* loop, const char* service, const struct addrinfo* hints) { char hostname_ascii[256]; - size_t nodesize = 0; - size_t servicesize = 0; - size_t hintssize = 0; + int nodesize = 0; + int servicesize = 0; + int hintssize = 0; char* alloc_ptr = NULL; - ssize_t rc; + int err; + long rc; if (req == NULL || (node == NULL && service == NULL)) { return UV_EINVAL; @@ -266,36 +286,56 @@ int uv_getaddrinfo(uv_loop_t* loop, hostname_ascii + sizeof(hostname_ascii)); if (rc < 0) return rc; - nodesize = strlen(hostname_ascii) + 1; + nodesize = ALIGNED_SIZE(MultiByteToWideChar(CP_UTF8, 0, hostname_ascii, + -1, NULL, 0) * sizeof(WCHAR)); + if (nodesize == 0) { + err = GetLastError(); + goto error; + } node = hostname_ascii; } if (service != NULL) { - rc = uv_wtf8_length_as_utf16(service); - if (rc < 0) - return rc; - servicesize = rc; + servicesize = ALIGNED_SIZE(MultiByteToWideChar(CP_UTF8, + 0, + service, + -1, + NULL, + 0) * + sizeof(WCHAR)); + if (servicesize == 0) { + err = GetLastError(); + goto error; + } } if (hints != NULL) { hintssize = ALIGNED_SIZE(sizeof(struct addrinfoW)); } /* allocate memory for inputs, and partition it as needed */ - alloc_ptr = uv__malloc(ALIGNED_SIZE(nodesize * sizeof(WCHAR)) + - ALIGNED_SIZE(servicesize * sizeof(WCHAR)) + - hintssize); - if (!alloc_ptr) - return UV_ENOMEM; + alloc_ptr = (char*)uv__malloc(nodesize + servicesize + hintssize); + if (!alloc_ptr) { + err = WSAENOBUFS; + goto error; + } /* save alloc_ptr now so we can free if error */ - req->alloc = (void*) alloc_ptr; + req->alloc = (void*)alloc_ptr; /* Convert node string to UTF16 into allocated memory and save pointer in the - * request. The node here has been converted to ascii. */ + * request. */ if (node != NULL) { - req->node = (WCHAR*) alloc_ptr; - uv_wtf8_to_utf16(node, (WCHAR*) alloc_ptr, nodesize); - alloc_ptr += ALIGNED_SIZE(nodesize * sizeof(WCHAR)); + req->node = (WCHAR*)alloc_ptr; + if (MultiByteToWideChar(CP_UTF8, + 0, + node, + -1, + (WCHAR*) alloc_ptr, + nodesize / sizeof(WCHAR)) == 0) { + err = GetLastError(); + goto error; + } + alloc_ptr += nodesize; } else { req->node = NULL; } @@ -303,16 +343,24 @@ int uv_getaddrinfo(uv_loop_t* loop, /* Convert service string to UTF16 into allocated memory and save pointer in * the req. */ if (service != NULL) { - req->service = (WCHAR*) alloc_ptr; - uv_wtf8_to_utf16(service, (WCHAR*) alloc_ptr, servicesize); - alloc_ptr += ALIGNED_SIZE(servicesize * sizeof(WCHAR)); + req->service = (WCHAR*)alloc_ptr; + if (MultiByteToWideChar(CP_UTF8, + 0, + service, + -1, + (WCHAR*) alloc_ptr, + servicesize / sizeof(WCHAR)) == 0) { + err = GetLastError(); + goto error; + } + alloc_ptr += servicesize; } else { req->service = NULL; } /* copy hints to allocated memory and save pointer in req */ if (hints != NULL) { - req->addrinfow = (struct addrinfoW*) alloc_ptr; + req->addrinfow = (struct addrinfoW*)alloc_ptr; req->addrinfow->ai_family = hints->ai_family; req->addrinfow->ai_socktype = hints->ai_socktype; req->addrinfow->ai_protocol = hints->ai_protocol; @@ -339,11 +387,19 @@ int uv_getaddrinfo(uv_loop_t* loop, uv__getaddrinfo_done(&req->work_req, 0); return req->retcode; } + +error: + if (req != NULL) { + uv__free(req->alloc); + req->alloc = NULL; + } + return uv_translate_sys_error(err); } int uv_if_indextoname(unsigned int ifindex, char* buffer, size_t* size) { NET_LUID luid; wchar_t wname[NDIS_IF_MAX_STRING_SIZE + 1]; /* Add one for the NUL. */ + DWORD bufsize; int r; if (buffer == NULL || size == NULL || *size == 0) @@ -359,7 +415,31 @@ int uv_if_indextoname(unsigned int ifindex, char* buffer, size_t* size) { if (r != 0) return uv_translate_sys_error(r); - return uv__copy_utf16_to_utf8(wname, -1, buffer, size); + /* Check how much space we need */ + bufsize = WideCharToMultiByte(CP_UTF8, 0, wname, -1, NULL, 0, NULL, NULL); + + if (bufsize == 0) { + return uv_translate_sys_error(GetLastError()); + } else if (bufsize > *size) { + *size = bufsize; + return UV_ENOBUFS; + } + + /* Convert to UTF-8 */ + bufsize = WideCharToMultiByte(CP_UTF8, + 0, + wname, + -1, + buffer, + *size, + NULL, + NULL); + + if (bufsize == 0) + return uv_translate_sys_error(GetLastError()); + + *size = bufsize - 1; + return 0; } int uv_if_indextoiid(unsigned int ifindex, char* buffer, size_t* size) { diff --git a/src/win/getnameinfo.c b/src/win/getnameinfo.c index 3286317..b377338 100644 --- a/src/win/getnameinfo.c +++ b/src/win/getnameinfo.c @@ -42,7 +42,6 @@ static void uv__getnameinfo_work(struct uv__work* w) { uv_getnameinfo_t* req; WCHAR host[NI_MAXHOST]; WCHAR service[NI_MAXSERV]; - size_t size; int ret; req = container_of(w, uv_getnameinfo_t, work_req); @@ -58,17 +57,29 @@ static void uv__getnameinfo_work(struct uv__work* w) { return; } - size = sizeof(req->host); - ret = uv__copy_utf16_to_utf8(host, -1, req->host, &size); - if (ret < 0) { - req->retcode = ret; + ret = WideCharToMultiByte(CP_UTF8, + 0, + host, + -1, + req->host, + sizeof(req->host), + NULL, + NULL); + if (ret == 0) { + req->retcode = uv_translate_sys_error(GetLastError()); return; } - size = sizeof(req->service); - ret = uv__copy_utf16_to_utf8(service, -1, req->service, &size); - if (ret < 0) { - req->retcode = ret; + ret = WideCharToMultiByte(CP_UTF8, + 0, + service, + -1, + req->service, + sizeof(req->service), + NULL, + NULL); + if (ret == 0) { + req->retcode = uv_translate_sys_error(GetLastError()); } } diff --git a/src/win/handle-inl.h b/src/win/handle-inl.h index 4722e85..5c843c2 100644 --- a/src/win/handle-inl.h +++ b/src/win/handle-inl.h @@ -75,7 +75,7 @@ #define uv__handle_close(handle) \ do { \ - uv__queue_remove(&(handle)->handle_queue); \ + QUEUE_REMOVE(&(handle)->handle_queue); \ uv__active_handle_rm((uv_handle_t*) (handle)); \ \ (handle)->flags |= UV_HANDLE_CLOSED; \ diff --git a/src/win/internal.h b/src/win/internal.h index c3f1cd6..c02db84 100644 --- a/src/win/internal.h +++ b/src/win/internal.h @@ -170,8 +170,18 @@ void uv__process_tty_read_req(uv_loop_t* loop, uv_tty_t* handle, uv_req_t* req); void uv__process_tty_write_req(uv_loop_t* loop, uv_tty_t* handle, uv_write_t* req); -#define uv__process_tty_accept_req(loop, handle, req) abort() -#define uv__process_tty_connect_req(loop, handle, req) abort() +/* + * uv__process_tty_accept_req() is a stub to keep DELEGATE_STREAM_REQ working + * TODO: find a way to remove it + */ +void uv__process_tty_accept_req(uv_loop_t* loop, uv_tty_t* handle, + uv_req_t* raw_req); +/* + * uv__process_tty_connect_req() is a stub to keep DELEGATE_STREAM_REQ working + * TODO: find a way to remove it + */ +void uv__process_tty_connect_req(uv_loop_t* loop, uv_tty_t* handle, + uv_connect_t* req); void uv__process_tty_shutdown_req(uv_loop_t* loop, uv_tty_t* stream, uv_shutdown_t* req); @@ -259,9 +269,9 @@ void uv__util_init(void); uint64_t uv__hrtime(unsigned int scale); __declspec(noreturn) void uv_fatal_error(const int errorno, const char* syscall); -int uv__convert_utf16_to_utf8(const WCHAR* utf16, size_t utf16len, char** utf8); -int uv__copy_utf16_to_utf8(const WCHAR* utf16, size_t utf16len, char* utf8, size_t *size); -int uv__convert_utf8_to_utf16(const char* utf8, WCHAR** utf16); +int uv__getpwuid_r(uv_passwd_t* pwd); +int uv__convert_utf16_to_utf8(const WCHAR* utf16, int utf16len, char** utf8); +int uv__convert_utf8_to_utf16(const char* utf8, int utf8len, WCHAR** utf16); typedef int (WINAPI *uv__peersockfunc)(SOCKET, struct sockaddr*, int*); diff --git a/src/win/pipe.c b/src/win/pipe.c index 3c8abe1..9984618 100644 --- a/src/win/pipe.c +++ b/src/win/pipe.c @@ -49,13 +49,13 @@ static const int default_pending_pipe_instances = 4; /* Pipe prefix */ static char pipe_prefix[] = "\\\\?\\pipe"; -static const size_t pipe_prefix_len = sizeof(pipe_prefix) - 1; +static const int pipe_prefix_len = sizeof(pipe_prefix) - 1; /* IPC incoming xfer queue item. */ typedef struct { uv__ipc_socket_xfer_type_t xfer_type; uv__ipc_socket_xfer_info_t xfer_info; - struct uv__queue member; + QUEUE member; } uv__ipc_xfer_queue_item_t; /* IPC frame header flags. */ @@ -98,14 +98,6 @@ static void eof_timer_destroy(uv_pipe_t* pipe); static void eof_timer_close_cb(uv_handle_t* handle); -/* Does the file path contain embedded nul bytes? */ -static int includes_nul(const char *s, size_t n) { - if (n == 0) - return 0; - return NULL != memchr(s, '\0', n); -} - - static void uv__unique_pipe_name(char* ptr, char* name, size_t size) { snprintf(name, size, "\\\\?\\pipe\\uv\\%p-%lu", ptr, GetCurrentProcessId()); } @@ -119,7 +111,7 @@ int uv_pipe_init(uv_loop_t* loop, uv_pipe_t* handle, int ipc) { handle->name = NULL; handle->pipe.conn.ipc_remote_pid = 0; handle->pipe.conn.ipc_data_frame.payload_remaining = 0; - uv__queue_init(&handle->pipe.conn.ipc_xfer_queue); + QUEUE_INIT(&handle->pipe.conn.ipc_xfer_queue); handle->pipe.conn.ipc_xfer_queue_length = 0; handle->ipc = ipc; handle->pipe.conn.non_overlapped_writes_tail = NULL; @@ -199,7 +191,7 @@ static void close_pipe(uv_pipe_t* pipe) { if (pipe->u.fd == -1) CloseHandle(pipe->handle); else - _close(pipe->u.fd); + close(pipe->u.fd); pipe->u.fd = -1; pipe->handle = INVALID_HANDLE_VALUE; @@ -645,13 +637,13 @@ void uv__pipe_endgame(uv_loop_t* loop, uv_pipe_t* handle) { if (handle->flags & UV_HANDLE_CONNECTION) { /* Free pending sockets */ - while (!uv__queue_empty(&handle->pipe.conn.ipc_xfer_queue)) { - struct uv__queue* q; + while (!QUEUE_EMPTY(&handle->pipe.conn.ipc_xfer_queue)) { + QUEUE* q; SOCKET socket; - q = uv__queue_head(&handle->pipe.conn.ipc_xfer_queue); - uv__queue_remove(q); - xfer_queue_item = uv__queue_data(q, uv__ipc_xfer_queue_item_t, member); + q = QUEUE_HEAD(&handle->pipe.conn.ipc_xfer_queue); + QUEUE_REMOVE(q); + xfer_queue_item = QUEUE_DATA(q, uv__ipc_xfer_queue_item_t, member); /* Materialize socket and close it */ socket = WSASocketW(FROM_PROTOCOL_INFO, @@ -702,60 +694,28 @@ void uv_pipe_pending_instances(uv_pipe_t* handle, int count) { /* Creates a pipe server. */ int uv_pipe_bind(uv_pipe_t* handle, const char* name) { - return uv_pipe_bind2(handle, name, strlen(name), 0); -} - - -int uv_pipe_bind2(uv_pipe_t* handle, - const char* name, - size_t namelen, - unsigned int flags) { uv_loop_t* loop = handle->loop; - int i, err; + int i, err, nameSize; uv_pipe_accept_t* req; - char* name_copy; - if (flags & ~UV_PIPE_NO_TRUNCATE) { - return UV_EINVAL; - } - - if (name == NULL) { - return UV_EINVAL; - } - - if (namelen == 0) { - return UV_EINVAL; - } - - if (includes_nul(name, namelen)) { + if (handle->flags & UV_HANDLE_BOUND) { return UV_EINVAL; } - if (handle->flags & UV_HANDLE_BOUND) { + if (!name) { return UV_EINVAL; } - if (uv__is_closing(handle)) { return UV_EINVAL; } - - name_copy = uv__malloc(namelen + 1); - if (name_copy == NULL) { - return UV_ENOMEM; - } - - memcpy(name_copy, name, namelen); - name_copy[namelen] = '\0'; - if (!(handle->flags & UV_HANDLE_PIPESERVER)) { handle->pipe.serv.pending_instances = default_pending_pipe_instances; } - err = UV_ENOMEM; handle->pipe.serv.accept_reqs = (uv_pipe_accept_t*) uv__malloc(sizeof(uv_pipe_accept_t) * handle->pipe.serv.pending_instances); - if (handle->pipe.serv.accept_reqs == NULL) { - goto error; + if (!handle->pipe.serv.accept_reqs) { + uv_fatal_error(ERROR_OUTOFMEMORY, "uv__malloc"); } for (i = 0; i < handle->pipe.serv.pending_instances; i++) { @@ -766,12 +726,20 @@ int uv_pipe_bind2(uv_pipe_t* handle, req->next_pending = NULL; } - /* TODO(bnoordhuis) Add converters that take a |length| parameter. */ - err = uv__convert_utf8_to_utf16(name_copy, &handle->name); - uv__free(name_copy); - name_copy = NULL; + /* Convert name to UTF16. */ + nameSize = MultiByteToWideChar(CP_UTF8, 0, name, -1, NULL, 0) * sizeof(WCHAR); + handle->name = uv__malloc(nameSize); + if (!handle->name) { + uv_fatal_error(ERROR_OUTOFMEMORY, "uv__malloc"); + } - if (err) { + if (!MultiByteToWideChar(CP_UTF8, + 0, + name, + -1, + handle->name, + nameSize / sizeof(WCHAR))) { + err = GetLastError(); goto error; } @@ -785,11 +753,9 @@ int uv_pipe_bind2(uv_pipe_t* handle, TRUE)) { err = GetLastError(); if (err == ERROR_ACCESS_DENIED) { - err = UV_EADDRINUSE; + err = WSAEADDRINUSE; /* Translates to UV_EADDRINUSE. */ } else if (err == ERROR_PATH_NOT_FOUND || err == ERROR_INVALID_NAME) { - err = UV_EACCES; - } else { - err = uv_translate_sys_error(err); + err = WSAEACCES; /* Translates to UV_EACCES. */ } goto error; } @@ -801,13 +767,12 @@ int uv_pipe_bind2(uv_pipe_t* handle, return 0; error: - uv__free(handle->pipe.serv.accept_reqs); - uv__free(handle->name); - uv__free(name_copy); - handle->pipe.serv.accept_reqs = NULL; - handle->name = NULL; + if (handle->name) { + uv__free(handle->name); + handle->name = NULL; + } - return err; + return uv_translate_sys_error(err); } @@ -827,17 +792,15 @@ static DWORD WINAPI pipe_connect_thread_proc(void* parameter) { /* We're here because CreateFile on a pipe returned ERROR_PIPE_BUSY. We wait * up to 30 seconds for the pipe to become available with WaitNamedPipe. */ - while (WaitNamedPipeW(req->u.connect.name, 30000)) { + while (WaitNamedPipeW(handle->name, 30000)) { /* The pipe is now available, try to connect. */ - pipeHandle = open_named_pipe(req->u.connect.name, &duplex_flags); + pipeHandle = open_named_pipe(handle->name, &duplex_flags); if (pipeHandle != INVALID_HANDLE_VALUE) break; SwitchToThread(); } - uv__free(req->u.connect.name); - req->u.connect.name = NULL; if (pipeHandle != INVALID_HANDLE_VALUE) { SET_REQ_SUCCESS(req); req->u.connect.pipeHandle = pipeHandle; @@ -853,70 +816,18 @@ static DWORD WINAPI pipe_connect_thread_proc(void* parameter) { } -void uv_pipe_connect(uv_connect_t* req, - uv_pipe_t* handle, - const char* name, - uv_connect_cb cb) { - uv_loop_t* loop; - int err; - - err = uv_pipe_connect2(req, handle, name, strlen(name), 0, cb); - - if (err) { - loop = handle->loop; - /* Make this req pending reporting an error. */ - SET_REQ_ERROR(req, err); - uv__insert_pending_req(loop, (uv_req_t*) req); - handle->reqs_pending++; - REGISTER_HANDLE_REQ(loop, handle, req); - } -} - - -int uv_pipe_connect2(uv_connect_t* req, - uv_pipe_t* handle, - const char* name, - size_t namelen, - unsigned int flags, - uv_connect_cb cb) { - uv_loop_t* loop; - int err; - size_t nameSize; +void uv_pipe_connect(uv_connect_t* req, uv_pipe_t* handle, + const char* name, uv_connect_cb cb) { + uv_loop_t* loop = handle->loop; + int err, nameSize; HANDLE pipeHandle = INVALID_HANDLE_VALUE; DWORD duplex_flags; - char* name_copy; - loop = handle->loop; UV_REQ_INIT(req, UV_CONNECT); req->handle = (uv_stream_t*) handle; req->cb = cb; req->u.connect.pipeHandle = INVALID_HANDLE_VALUE; req->u.connect.duplex_flags = 0; - req->u.connect.name = NULL; - - if (flags & ~UV_PIPE_NO_TRUNCATE) { - return UV_EINVAL; - } - - if (name == NULL) { - return UV_EINVAL; - } - - if (namelen == 0) { - return UV_EINVAL; - } - - if (includes_nul(name, namelen)) { - return UV_EINVAL; - } - - name_copy = uv__malloc(namelen + 1); - if (name_copy == NULL) { - return UV_ENOMEM; - } - - memcpy(name_copy, name, namelen); - name_copy[namelen] = '\0'; if (handle->flags & UV_HANDLE_PIPESERVER) { err = ERROR_INVALID_PARAMETER; @@ -928,33 +839,30 @@ int uv_pipe_connect2(uv_connect_t* req, } uv__pipe_connection_init(handle); - /* TODO(bnoordhuis) Add converters that take a |length| parameter. */ - err = uv__convert_utf8_to_utf16(name_copy, &handle->name); - uv__free(name_copy); - name_copy = NULL; + /* Convert name to UTF16. */ + nameSize = MultiByteToWideChar(CP_UTF8, 0, name, -1, NULL, 0) * sizeof(WCHAR); + handle->name = uv__malloc(nameSize); + if (!handle->name) { + uv_fatal_error(ERROR_OUTOFMEMORY, "uv__malloc"); + } - if (err) { - err = ERROR_NO_UNICODE_TRANSLATION; + if (!MultiByteToWideChar(CP_UTF8, + 0, + name, + -1, + handle->name, + nameSize / sizeof(WCHAR))) { + err = GetLastError(); goto error; } pipeHandle = open_named_pipe(handle->name, &duplex_flags); if (pipeHandle == INVALID_HANDLE_VALUE) { if (GetLastError() == ERROR_PIPE_BUSY) { - nameSize = (wcslen(handle->name) + 1) * sizeof(WCHAR); - req->u.connect.name = uv__malloc(nameSize); - if (!req->u.connect.name) { - uv_fatal_error(ERROR_OUTOFMEMORY, "uv__malloc"); - } - - memcpy(req->u.connect.name, handle->name, nameSize); - /* Wait for the server to make a pipe instance available. */ if (!QueueUserWorkItem(&pipe_connect_thread_proc, req, WT_EXECUTELONGFUNCTION)) { - uv__free(req->u.connect.name); - req->u.connect.name = NULL; err = GetLastError(); goto error; } @@ -962,7 +870,7 @@ int uv_pipe_connect2(uv_connect_t* req, REGISTER_HANDLE_REQ(loop, handle, req); handle->reqs_pending++; - return 0; + return; } err = GetLastError(); @@ -975,11 +883,9 @@ int uv_pipe_connect2(uv_connect_t* req, uv__insert_pending_req(loop, (uv_req_t*) req); handle->reqs_pending++; REGISTER_HANDLE_REQ(loop, handle, req); - return 0; + return; error: - uv__free(name_copy); - if (handle->name) { uv__free(handle->name); handle->name = NULL; @@ -993,7 +899,7 @@ error: uv__insert_pending_req(loop, (uv_req_t*) req); handle->reqs_pending++; REGISTER_HANDLE_REQ(loop, handle, req); - return 0; + return; } @@ -1144,29 +1050,28 @@ int uv__pipe_accept(uv_pipe_t* server, uv_stream_t* client) { uv_loop_t* loop = server->loop; uv_pipe_t* pipe_client; uv_pipe_accept_t* req; - struct uv__queue* q; + QUEUE* q; uv__ipc_xfer_queue_item_t* item; int err; if (server->ipc) { - if (uv__queue_empty(&server->pipe.conn.ipc_xfer_queue)) { + if (QUEUE_EMPTY(&server->pipe.conn.ipc_xfer_queue)) { /* No valid pending sockets. */ return WSAEWOULDBLOCK; } - q = uv__queue_head(&server->pipe.conn.ipc_xfer_queue); - uv__queue_remove(q); + q = QUEUE_HEAD(&server->pipe.conn.ipc_xfer_queue); + QUEUE_REMOVE(q); server->pipe.conn.ipc_xfer_queue_length--; - item = uv__queue_data(q, uv__ipc_xfer_queue_item_t, member); + item = QUEUE_DATA(q, uv__ipc_xfer_queue_item_t, member); err = uv__tcp_xfer_import( (uv_tcp_t*) client, item->xfer_type, &item->xfer_info); - - uv__free(item); - if (err != 0) return err; + uv__free(item); + } else { pipe_client = (uv_pipe_t*) client; uv__pipe_connection_init(pipe_client); @@ -1733,13 +1638,9 @@ static DWORD uv__pipe_get_ipc_remote_pid(uv_pipe_t* handle) { /* If the both ends of the IPC pipe are owned by the same process, * the remote end pid may not yet be set. If so, do it here. * TODO: this is weird; it'd probably better to use a handshake. */ - if (*pid == 0) { - GetNamedPipeClientProcessId(handle->handle, pid); - if (*pid == GetCurrentProcessId()) { - GetNamedPipeServerProcessId(handle->handle, pid); - } - } - + if (*pid == 0) + *pid = GetCurrentProcessId(); + return *pid; } @@ -1911,7 +1812,7 @@ static void uv__pipe_queue_ipc_xfer_info( item->xfer_type = xfer_type; item->xfer_info = *xfer_info; - uv__queue_insert_tail(&handle->pipe.conn.ipc_xfer_queue, &item->member); + QUEUE_INSERT_TAIL(&handle->pipe.conn.ipc_xfer_queue, &item->member); handle->pipe.conn.ipc_xfer_queue_length++; } @@ -2168,9 +2069,9 @@ void uv__process_pipe_write_req(uv_loop_t* loop, uv_pipe_t* handle, uv__queue_non_overlapped_write(handle); } - if (handle->stream.conn.write_reqs_pending == 0 && - uv__is_stream_shutting(handle)) - uv__pipe_shutdown(loop, handle, handle->stream.conn.shutdown_req); + if (handle->stream.conn.write_reqs_pending == 0) + if (handle->flags & UV_HANDLE_SHUTTING) + uv__pipe_shutdown(loop, handle, handle->stream.conn.shutdown_req); DECREASE_PENDING_REQ_COUNT(handle); } @@ -2225,10 +2126,7 @@ void uv__process_pipe_connect_req(uv_loop_t* loop, uv_pipe_t* handle, if (REQ_SUCCESS(req)) { pipeHandle = req->u.connect.pipeHandle; duplex_flags = req->u.connect.duplex_flags; - if (handle->flags & UV_HANDLE_CLOSING) - err = UV_ECANCELED; - else - err = uv__set_pipe_handle(loop, handle, pipeHandle, -1, duplex_flags); + err = uv__set_pipe_handle(loop, handle, pipeHandle, -1, duplex_flags); if (err) CloseHandle(pipeHandle); } else { @@ -2251,6 +2149,7 @@ void uv__process_pipe_shutdown_req(uv_loop_t* loop, uv_pipe_t* handle, /* Clear the shutdown_req field so we don't go here again. */ handle->stream.conn.shutdown_req = NULL; + handle->flags &= ~UV_HANDLE_SHUTTING; UNREGISTER_HANDLE_REQ(loop, handle, req); if (handle->flags & UV_HANDLE_CLOSING) { @@ -2443,10 +2342,7 @@ int uv_pipe_open(uv_pipe_t* pipe, uv_file file) { if (pipe->ipc) { assert(!(pipe->flags & UV_HANDLE_NON_OVERLAPPED_PIPE)); - GetNamedPipeClientProcessId(os_handle, &pipe->pipe.conn.ipc_remote_pid); - if (pipe->pipe.conn.ipc_remote_pid == GetCurrentProcessId()) { - GetNamedPipeServerProcessId(os_handle, &pipe->pipe.conn.ipc_remote_pid); - } + pipe->pipe.conn.ipc_remote_pid = uv_os_getppid(); assert(pipe->pipe.conn.ipc_remote_pid != (DWORD)(uv_pid_t) -1); } return 0; @@ -2459,6 +2355,7 @@ static int uv__pipe_getname(const uv_pipe_t* handle, char* buffer, size_t* size) FILE_NAME_INFORMATION tmp_name_info; FILE_NAME_INFORMATION* name_info; WCHAR* name_buf; + unsigned int addrlen; unsigned int name_size; unsigned int name_len; int err; @@ -2469,7 +2366,46 @@ static int uv__pipe_getname(const uv_pipe_t* handle, char* buffer, size_t* size) if (handle->name != NULL) { /* The user might try to query the name before we are connected, * and this is just easier to return the cached value if we have it. */ - return uv__copy_utf16_to_utf8(handle->name, -1, buffer, size); + name_buf = handle->name; + name_len = wcslen(name_buf); + + /* check how much space we need */ + addrlen = WideCharToMultiByte(CP_UTF8, + 0, + name_buf, + name_len, + NULL, + 0, + NULL, + NULL); + if (!addrlen) { + *size = 0; + err = uv_translate_sys_error(GetLastError()); + return err; + } else if (addrlen >= *size) { + *size = addrlen + 1; + err = UV_ENOBUFS; + goto error; + } + + addrlen = WideCharToMultiByte(CP_UTF8, + 0, + name_buf, + name_len, + buffer, + addrlen, + NULL, + NULL); + if (!addrlen) { + *size = 0; + err = uv_translate_sys_error(GetLastError()); + return err; + } + + *size = addrlen; + buffer[addrlen] = '\0'; + + return 0; } if (handle->handle == INVALID_HANDLE_VALUE) { @@ -2497,7 +2433,8 @@ static int uv__pipe_getname(const uv_pipe_t* handle, char* buffer, size_t* size) name_info = uv__malloc(name_size); if (!name_info) { *size = 0; - return UV_ENOMEM; + err = UV_ENOMEM; + goto cleanup; } nt_status = pNtQueryInformationFile(handle->handle, @@ -2530,19 +2467,51 @@ static int uv__pipe_getname(const uv_pipe_t* handle, char* buffer, size_t* size) name_len /= sizeof(WCHAR); - /* "\\\\.\\pipe" + name */ - if (*size < pipe_prefix_len) { + /* check how much space we need */ + addrlen = WideCharToMultiByte(CP_UTF8, + 0, + name_buf, + name_len, + NULL, + 0, + NULL, + NULL); + if (!addrlen) { *size = 0; + err = uv_translate_sys_error(GetLastError()); + goto error; + } else if (pipe_prefix_len + addrlen >= *size) { + /* "\\\\.\\pipe" + name */ + *size = pipe_prefix_len + addrlen + 1; + err = UV_ENOBUFS; + goto error; } - else { - memcpy(buffer, pipe_prefix, pipe_prefix_len); - *size -= pipe_prefix_len; + + memcpy(buffer, pipe_prefix, pipe_prefix_len); + addrlen = WideCharToMultiByte(CP_UTF8, + 0, + name_buf, + name_len, + buffer+pipe_prefix_len, + *size-pipe_prefix_len, + NULL, + NULL); + if (!addrlen) { + *size = 0; + err = uv_translate_sys_error(GetLastError()); + goto error; } - err = uv__copy_utf16_to_utf8(name_buf, name_len, buffer+pipe_prefix_len, size); - *size += pipe_prefix_len; + + addrlen += pipe_prefix_len; + *size = addrlen; + buffer[addrlen] = '\0'; + + err = 0; error: uv__free(name_info); + +cleanup: return err; } diff --git a/src/win/poll.c b/src/win/poll.c index 7fec2b9..bd531b0 100644 --- a/src/win/poll.c +++ b/src/win/poll.c @@ -425,8 +425,9 @@ int uv_poll_init_socket(uv_loop_t* loop, uv_poll_t* handle, return uv_translate_sys_error(WSAGetLastError()); /* Try to obtain a base handle for the socket. This increases this chances that - * we find an AFD handle and are able to use the fast poll mechanism. - */ + * we find an AFD handle and are able to use the fast poll mechanism. This will + * always fail on windows XP/2k3, since they don't support the. SIO_BASE_HANDLE + * ioctl. */ #ifndef NDEBUG base_socket = INVALID_SOCKET; #endif diff --git a/src/win/process.c b/src/win/process.c index 4e94dee..24c6333 100644 --- a/src/win/process.c +++ b/src/win/process.c @@ -26,15 +26,12 @@ #include #include #include -#include /* _alloca */ +#include /* alloca */ #include "uv.h" #include "internal.h" #include "handle-inl.h" #include "req-inl.h" -#include -#include -#include /* GetModuleBaseNameW */ #define SIGKILL 9 @@ -105,26 +102,38 @@ static void uv__init_global_job_handle(void) { &info, sizeof info)) uv_fatal_error(GetLastError(), "SetInformationJobObject"); +} - if (!AssignProcessToJobObject(uv_global_job_handle_, GetCurrentProcess())) { - /* Make sure this handle is functional. The Windows kernel has a bug that - * if the first use of AssignProcessToJobObject is for a Windows Store - * program, subsequent attempts to use the handle with fail with - * INVALID_PARAMETER (87). This is possibly because all uses of the handle - * must be for the same Terminal Services session. We can ensure it is tied - * to our current session now by adding ourself to it. We could remove - * ourself afterwards, but there doesn't seem to be a reason to. - */ - DWORD err = GetLastError(); - if (err != ERROR_ACCESS_DENIED) - uv_fatal_error(err, "AssignProcessToJobObject"); +static int uv__utf8_to_utf16_alloc(const char* s, WCHAR** ws_ptr) { + int ws_len, r; + WCHAR* ws; + + ws_len = MultiByteToWideChar(CP_UTF8, + 0, + s, + -1, + NULL, + 0); + if (ws_len <= 0) { + return GetLastError(); } -} + ws = (WCHAR*) uv__malloc(ws_len * sizeof(WCHAR)); + if (ws == NULL) { + return ERROR_OUTOFMEMORY; + } -static int uv__utf8_to_utf16_alloc(const char* s, WCHAR** ws_ptr) { - return uv__convert_utf8_to_utf16(s, ws_ptr); + r = MultiByteToWideChar(CP_UTF8, + 0, + s, + -1, + ws, + ws_len); + assert(r == ws_len); + + *ws_ptr = ws; + return 0; } @@ -135,6 +144,7 @@ static void uv__process_init(uv_loop_t* loop, uv_process_t* handle) { handle->exit_signal = 0; handle->wait_handle = INVALID_HANDLE_VALUE; handle->process_handle = INVALID_HANDLE_VALUE; + handle->child_stdio_buffer = NULL; handle->exit_cb_pending = 0; UV_REQ_INIT(&handle->exit_req, UV_PROCESS_EXIT); @@ -304,9 +314,8 @@ static WCHAR* path_search_walk_ext(const WCHAR *dir, * - If there's really only a filename, check the current directory for file, * then search all path directories. * - * - If filename specified has *any* extension, or already contains a path - * and the UV_PROCESS_WINDOWS_FILE_PATH_EXACT_NAME flag is specified, - * search for the file with the exact specified filename first. + * - If filename specified has *any* extension, search for the file with the + * specified extension first. * * - If the literal filename is not found in a directory, try *appending* * (not replacing) .com first and then .exe. @@ -332,8 +341,7 @@ static WCHAR* path_search_walk_ext(const WCHAR *dir, */ static WCHAR* search_path(const WCHAR *file, WCHAR *cwd, - const WCHAR *path, - unsigned int flags) { + const WCHAR *path) { int file_has_dir; WCHAR* result = NULL; WCHAR *file_name_start; @@ -374,21 +382,19 @@ static WCHAR* search_path(const WCHAR *file, file, file_name_start - file, file_name_start, file_len - (file_name_start - file), cwd, cwd_len, - name_has_ext || (flags & UV_PROCESS_WINDOWS_FILE_PATH_EXACT_NAME)); + name_has_ext); } else { dir_end = path; - if (NeedCurrentDirectoryForExePathW(L"")) { - /* The file is really only a name; look in cwd first, then scan path */ - result = path_search_walk_ext(L"", 0, - file, file_len, - cwd, cwd_len, - name_has_ext); - } + /* The file is really only a name; look in cwd first, then scan path */ + result = path_search_walk_ext(L"", 0, + file, file_len, + cwd, cwd_len, + name_has_ext); while (result == NULL) { - if (dir_end == NULL || *dir_end == L'\0') { + if (*dir_end == L'\0') { break; } @@ -513,7 +519,7 @@ WCHAR* quote_cmd_arg(const WCHAR *source, WCHAR *target) { } } target[0] = L'\0'; - _wcsrev(start); + wcsrev(start); *(target++) = L'"'; return target; } @@ -531,15 +537,21 @@ int make_program_args(char** args, int verbatim_arguments, WCHAR** dst_ptr) { /* Count the required size. */ for (arg = args; *arg; arg++) { - ssize_t arg_len; - - arg_len = uv_wtf8_length_as_utf16(*arg); - if (arg_len < 0) - return arg_len; + DWORD arg_len; + + arg_len = MultiByteToWideChar(CP_UTF8, + 0, + *arg, + -1, + NULL, + 0); + if (arg_len == 0) { + return GetLastError(); + } dst_len += arg_len; - if ((size_t) arg_len > temp_buffer_len) + if (arg_len > temp_buffer_len) temp_buffer_len = arg_len; arg_count++; @@ -550,28 +562,34 @@ int make_program_args(char** args, int verbatim_arguments, WCHAR** dst_ptr) { dst_len = dst_len * 2 + arg_count * 2; /* Allocate buffer for the final command line. */ - dst = uv__malloc(dst_len * sizeof(WCHAR)); + dst = (WCHAR*) uv__malloc(dst_len * sizeof(WCHAR)); if (dst == NULL) { - err = UV_ENOMEM; + err = ERROR_OUTOFMEMORY; goto error; } /* Allocate temporary working buffer. */ - temp_buffer = uv__malloc(temp_buffer_len * sizeof(WCHAR)); + temp_buffer = (WCHAR*) uv__malloc(temp_buffer_len * sizeof(WCHAR)); if (temp_buffer == NULL) { - err = UV_ENOMEM; + err = ERROR_OUTOFMEMORY; goto error; } pos = dst; for (arg = args; *arg; arg++) { - ssize_t arg_len; + DWORD arg_len; /* Convert argument to wide char. */ - arg_len = uv_wtf8_length_as_utf16(*arg); - assert(arg_len > 0); - assert(temp_buffer_len >= (size_t) arg_len); - uv_wtf8_to_utf16(*arg, temp_buffer, arg_len); + arg_len = MultiByteToWideChar(CP_UTF8, + 0, + *arg, + -1, + temp_buffer, + (int) (dst + dst_len - pos)); + if (arg_len == 0) { + err = GetLastError(); + goto error; + } if (verbatim_arguments) { /* Copy verbatim. */ @@ -583,7 +601,6 @@ int make_program_args(char** args, int verbatim_arguments, WCHAR** dst_ptr) { } *pos++ = *(arg + 1) ? L' ' : L'\0'; - assert(pos <= dst + dst_len); } uv__free(temp_buffer); @@ -617,8 +634,8 @@ int env_strncmp(const wchar_t* a, int na, const wchar_t* b) { assert(b_eq); nb = b_eq - b; - A = _alloca((na+1) * sizeof(wchar_t)); - B = _alloca((nb+1) * sizeof(wchar_t)); + A = alloca((na+1) * sizeof(wchar_t)); + B = alloca((nb+1) * sizeof(wchar_t)); r = LCMapStringW(LOCALE_INVARIANT, LCMAP_UPPERCASE, a, na, A, na); assert(r==na); @@ -669,43 +686,55 @@ int make_program_env(char* env_block[], WCHAR** dst_ptr) { WCHAR* ptr; char** env; size_t env_len = 0; - size_t len; + int len; size_t i; - size_t var_size; + DWORD var_size; size_t env_block_count = 1; /* 1 for null-terminator */ WCHAR* dst_copy; WCHAR** ptr_copy; WCHAR** env_copy; - size_t required_vars_value_len[ARRAY_SIZE(required_vars)]; + DWORD required_vars_value_len[ARRAY_SIZE(required_vars)]; /* first pass: determine size in UTF-16 */ for (env = env_block; *env; env++) { - ssize_t len; + int len; if (strchr(*env, '=')) { - len = uv_wtf8_length_as_utf16(*env); - if (len < 0) - return len; + len = MultiByteToWideChar(CP_UTF8, + 0, + *env, + -1, + NULL, + 0); + if (len <= 0) { + return GetLastError(); + } env_len += len; env_block_count++; } } /* second pass: copy to UTF-16 environment block */ - dst_copy = uv__malloc(env_len * sizeof(WCHAR)); + dst_copy = (WCHAR*)uv__malloc(env_len * sizeof(WCHAR)); if (dst_copy == NULL && env_len > 0) { - return UV_ENOMEM; + return ERROR_OUTOFMEMORY; } - env_copy = _alloca(env_block_count * sizeof(WCHAR*)); + env_copy = alloca(env_block_count * sizeof(WCHAR*)); ptr = dst_copy; ptr_copy = env_copy; for (env = env_block; *env; env++) { - ssize_t len; if (strchr(*env, '=')) { - len = uv_wtf8_length_as_utf16(*env); - assert(len > 0); - assert((size_t) len <= env_len - (ptr - dst_copy)); - uv_wtf8_to_utf16(*env, ptr, len); + len = MultiByteToWideChar(CP_UTF8, + 0, + *env, + -1, + ptr, + (int) (env_len - (ptr - dst_copy))); + if (len <= 0) { + DWORD err = GetLastError(); + uv__free(dst_copy); + return err; + } *ptr_copy++ = ptr; ptr += len; } @@ -723,7 +752,7 @@ int make_program_env(char* env_block[], WCHAR** dst_ptr) { cmp = -1; } else { cmp = env_strncmp(required_vars[i].wide_eq, - required_vars[i].len, + required_vars[i].len, *ptr_copy); } if (cmp < 0) { @@ -746,7 +775,7 @@ int make_program_env(char* env_block[], WCHAR** dst_ptr) { dst = uv__malloc((1+env_len) * sizeof(WCHAR)); if (!dst) { uv__free(dst_copy); - return UV_ENOMEM; + return ERROR_OUTOFMEMORY; } for (ptr = dst, ptr_copy = env_copy, i = 0; @@ -918,11 +947,9 @@ int uv_spawn(uv_loop_t* loop, STARTUPINFOW startup; PROCESS_INFORMATION info; DWORD process_flags; - BYTE* child_stdio_buffer; uv__process_init(loop, process); process->exit_cb = options->exit_cb; - child_stdio_buffer = NULL; if (options->flags & (UV_PROCESS_SETGID | UV_PROCESS_SETUID)) { return UV_ENOTSUP; @@ -937,7 +964,6 @@ int uv_spawn(uv_loop_t* loop, assert(!(options->flags & ~(UV_PROCESS_DETACHED | UV_PROCESS_SETGID | UV_PROCESS_SETUID | - UV_PROCESS_WINDOWS_FILE_PATH_EXACT_NAME | UV_PROCESS_WINDOWS_HIDE | UV_PROCESS_WINDOWS_HIDE_CONSOLE | UV_PROCESS_WINDOWS_HIDE_GUI | @@ -945,26 +971,26 @@ int uv_spawn(uv_loop_t* loop, err = uv__utf8_to_utf16_alloc(options->file, &application); if (err) - goto done_uv; + goto done; err = make_program_args( options->args, options->flags & UV_PROCESS_WINDOWS_VERBATIM_ARGUMENTS, &arguments); if (err) - goto done_uv; + goto done; if (options->env) { err = make_program_env(options->env, &env); if (err) - goto done_uv; + goto done; } if (options->cwd) { /* Explicit cwd */ err = uv__utf8_to_utf16_alloc(options->cwd, &cwd); if (err) - goto done_uv; + goto done; } else { /* Inherit cwd */ @@ -995,30 +1021,32 @@ int uv_spawn(uv_loop_t* loop, DWORD path_len, r; path_len = GetEnvironmentVariableW(L"PATH", NULL, 0); - if (path_len != 0) { - alloc_path = (WCHAR*) uv__malloc(path_len * sizeof(WCHAR)); - if (alloc_path == NULL) { - err = ERROR_OUTOFMEMORY; - goto done; - } - path = alloc_path; + if (path_len == 0) { + err = GetLastError(); + goto done; + } - r = GetEnvironmentVariableW(L"PATH", path, path_len); - if (r == 0 || r >= path_len) { - err = GetLastError(); - goto done; - } + alloc_path = (WCHAR*) uv__malloc(path_len * sizeof(WCHAR)); + if (alloc_path == NULL) { + err = ERROR_OUTOFMEMORY; + goto done; + } + path = alloc_path; + + r = GetEnvironmentVariableW(L"PATH", path, path_len); + if (r == 0 || r >= path_len) { + err = GetLastError(); + goto done; } } - err = uv__stdio_create(loop, options, &child_stdio_buffer); + err = uv__stdio_create(loop, options, &process->child_stdio_buffer); if (err) goto done; application_path = search_path(application, cwd, - path, - options->flags); + path); if (application_path == NULL) { /* Not found. */ err = ERROR_FILE_NOT_FOUND; @@ -1031,12 +1059,12 @@ int uv_spawn(uv_loop_t* loop, startup.lpTitle = NULL; startup.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW; - startup.cbReserved2 = uv__stdio_size(child_stdio_buffer); - startup.lpReserved2 = (BYTE*) child_stdio_buffer; + startup.cbReserved2 = uv__stdio_size(process->child_stdio_buffer); + startup.lpReserved2 = (BYTE*) process->child_stdio_buffer; - startup.hStdInput = uv__stdio_handle(child_stdio_buffer, 0); - startup.hStdOutput = uv__stdio_handle(child_stdio_buffer, 1); - startup.hStdError = uv__stdio_handle(child_stdio_buffer, 2); + startup.hStdInput = uv__stdio_handle(process->child_stdio_buffer, 0); + startup.hStdOutput = uv__stdio_handle(process->child_stdio_buffer, 1); + startup.hStdError = uv__stdio_handle(process->child_stdio_buffer, 2); process_flags = CREATE_UNICODE_ENVIRONMENT; @@ -1070,7 +1098,6 @@ int uv_spawn(uv_loop_t* loop, * breakaway. */ process_flags |= DETACHED_PROCESS | CREATE_NEW_PROCESS_GROUP; - process_flags |= CREATE_SUSPENDED; } if (!CreateProcessW(application_path, @@ -1088,6 +1115,11 @@ int uv_spawn(uv_loop_t* loop, goto done; } + /* Spawn succeeded. Beyond this point, failure is reported asynchronously. */ + + process->process_handle = info.hProcess; + process->pid = info.dwProcessId; + /* If the process isn't spawned as detached, assign to the global job object * so windows will kill it when the parent process dies. */ if (!(options->flags & UV_PROCESS_DETACHED)) { @@ -1110,19 +1142,6 @@ int uv_spawn(uv_loop_t* loop, } } - if (process_flags & CREATE_SUSPENDED) { - if (ResumeThread(info.hThread) == ((DWORD)-1)) { - err = GetLastError(); - TerminateProcess(info.hProcess, 1); - goto done; - } - } - - /* Spawn succeeded. Beyond this point, failure is reported asynchronously. */ - - process->process_handle = info.hProcess; - process->pid = info.dwProcessId; - /* Set IPC pid to all IPC pipes. */ for (i = 0; i < options->stdio_count; i++) { const uv_stdio_container_t* fdopt = &options->stdio[i]; @@ -1150,13 +1169,8 @@ int uv_spawn(uv_loop_t* loop, * made or the handle is closed, whichever happens first. */ uv__handle_start(process); - goto done_uv; - /* Cleanup, whether we succeeded or failed. */ done: - err = uv_translate_sys_error(err); - - done_uv: uv__free(application); uv__free(application_path); uv__free(arguments); @@ -1164,13 +1178,13 @@ int uv_spawn(uv_loop_t* loop, uv__free(env); uv__free(alloc_path); - if (child_stdio_buffer != NULL) { + if (process->child_stdio_buffer != NULL) { /* Clean up child stdio handles. */ - uv__stdio_destroy(child_stdio_buffer); - child_stdio_buffer = NULL; + uv__stdio_destroy(process->child_stdio_buffer); + process->child_stdio_buffer = NULL; } - return err; + return uv_translate_sys_error(err); } @@ -1179,134 +1193,13 @@ static int uv__kill(HANDLE process_handle, int signum) { return UV_EINVAL; } - /* Create a dump file for the targeted process, if the registry key - * `HKLM:Software\Microsoft\Windows\Windows Error Reporting\LocalDumps` - * exists. The location of the dumps can be influenced by the `DumpFolder` - * sub-key, which has a default value of `%LOCALAPPDATA%\CrashDumps`, see [0] - * for more detail. Note that if the dump folder does not exist, we attempt - * to create it, to match behavior with WER itself. - * [0]: https://learn.microsoft.com/en-us/windows/win32/wer/collecting-user-mode-dumps */ - if (signum == SIGQUIT) { - HKEY registry_key; - DWORD pid, ret; - WCHAR basename[MAX_PATH]; - - /* Get target process name. */ - GetModuleBaseNameW(process_handle, NULL, &basename[0], sizeof(basename)); - - /* Get PID of target process. */ - pid = GetProcessId(process_handle); - - /* Get LocalDumps directory path. */ - ret = RegOpenKeyExW( - HKEY_LOCAL_MACHINE, - L"SOFTWARE\\Microsoft\\Windows\\Windows Error Reporting\\LocalDumps", - 0, - KEY_QUERY_VALUE, - ®istry_key); - if (ret == ERROR_SUCCESS) { - HANDLE hDumpFile = NULL; - WCHAR dump_folder[MAX_PATH], dump_name[MAX_PATH]; - DWORD dump_folder_len = sizeof(dump_folder), key_type = 0; - ret = RegGetValueW(registry_key, - NULL, - L"DumpFolder", - RRF_RT_ANY, - &key_type, - (PVOID) dump_folder, - &dump_folder_len); - if (ret != ERROR_SUCCESS) { - /* Workaround for missing uuid.dll on MinGW. */ - static const GUID FOLDERID_LocalAppData_libuv = { - 0xf1b32785, 0x6fba, 0x4fcf, - {0x9d, 0x55, 0x7b, 0x8e, 0x7f, 0x15, 0x70, 0x91} - }; - - /* Default value for `dump_folder` is `%LOCALAPPDATA%\CrashDumps`. */ - WCHAR* localappdata; - SHGetKnownFolderPath(&FOLDERID_LocalAppData_libuv, - 0, - NULL, - &localappdata); - _snwprintf_s(dump_folder, - sizeof(dump_folder), - _TRUNCATE, - L"%ls\\CrashDumps", - localappdata); - CoTaskMemFree(localappdata); - } - RegCloseKey(registry_key); - - /* Create dump folder if it doesn't already exist. */ - CreateDirectoryW(dump_folder, NULL); - - /* Construct dump filename from process name and PID. */ - _snwprintf_s(dump_name, - sizeof(dump_name), - _TRUNCATE, - L"%ls\\%ls.%d.dmp", - dump_folder, - basename, - pid); - - hDumpFile = CreateFileW(dump_name, - GENERIC_WRITE, - 0, - NULL, - CREATE_NEW, - FILE_ATTRIBUTE_NORMAL, - NULL); - if (hDumpFile != INVALID_HANDLE_VALUE) { - DWORD dump_options, sym_options; - FILE_DISPOSITION_INFO DeleteOnClose = { TRUE }; - - /* If something goes wrong while writing it out, delete the file. */ - SetFileInformationByHandle(hDumpFile, - FileDispositionInfo, - &DeleteOnClose, - sizeof(DeleteOnClose)); - - /* Tell wine to dump ELF modules as well. */ - sym_options = SymGetOptions(); - SymSetOptions(sym_options | 0x40000000); - -/* MiniDumpWithAvxXStateContext might be undef in server2012r2 or mingw < 12 */ -#ifndef MiniDumpWithAvxXStateContext -#define MiniDumpWithAvxXStateContext 0x00200000 -#endif - /* We default to a fairly complete dump. In the future, we may want to - * allow clients to customize what kind of dump to create. */ - dump_options = MiniDumpWithFullMemory | - MiniDumpIgnoreInaccessibleMemory | - MiniDumpWithAvxXStateContext; - - if (MiniDumpWriteDump(process_handle, - pid, - hDumpFile, - dump_options, - NULL, - NULL, - NULL)) { - /* Don't delete the file on close if we successfully wrote it out. */ - FILE_DISPOSITION_INFO DontDeleteOnClose = { FALSE }; - SetFileInformationByHandle(hDumpFile, - FileDispositionInfo, - &DontDeleteOnClose, - sizeof(DontDeleteOnClose)); - } - SymSetOptions(sym_options); - CloseHandle(hDumpFile); - } - } - } - switch (signum) { - case SIGQUIT: case SIGTERM: case SIGKILL: case SIGINT: { /* Unconditionally terminate the process. On Windows, killed processes * normally return 1. */ + DWORD status; int err; if (TerminateProcess(process_handle, 1)) @@ -1316,7 +1209,8 @@ static int uv__kill(HANDLE process_handle, int signum) { * TerminateProcess will fail with ERROR_ACCESS_DENIED. */ err = GetLastError(); if (err == ERROR_ACCESS_DENIED && - WaitForSingleObject(process_handle, 0) == WAIT_OBJECT_0) { + GetExitCodeProcess(process_handle, &status) && + status != STILL_ACTIVE) { return UV_ESRCH; } @@ -1325,16 +1219,15 @@ static int uv__kill(HANDLE process_handle, int signum) { case 0: { /* Health check: is the process still alive? */ - switch (WaitForSingleObject(process_handle, 0)) { - case WAIT_OBJECT_0: - return UV_ESRCH; - case WAIT_FAILED: - return uv_translate_sys_error(GetLastError()); - case WAIT_TIMEOUT: - return 0; - default: - return UV_UNKNOWN; - } + DWORD status; + + if (!GetExitCodeProcess(process_handle, &status)) + return uv_translate_sys_error(GetLastError()); + + if (status != STILL_ACTIVE) + return UV_ESRCH; + + return 0; } default: @@ -1369,7 +1262,7 @@ int uv_kill(int pid, int signum) { if (pid == 0) { process_handle = GetCurrentProcess(); } else { - process_handle = OpenProcess(PROCESS_TERMINATE | PROCESS_QUERY_INFORMATION | SYNCHRONIZE, + process_handle = OpenProcess(PROCESS_TERMINATE | PROCESS_QUERY_INFORMATION, FALSE, pid); } diff --git a/src/win/stream.c b/src/win/stream.c index 7bf9ca3..292bf58 100644 --- a/src/win/stream.c +++ b/src/win/stream.c @@ -204,7 +204,7 @@ int uv_shutdown(uv_shutdown_t* req, uv_stream_t* handle, uv_shutdown_cb cb) { uv_loop_t* loop = handle->loop; if (!(handle->flags & UV_HANDLE_WRITABLE) || - uv__is_stream_shutting(handle) || + handle->flags & UV_HANDLE_SHUTTING || uv__is_closing(handle)) { return UV_ENOTCONN; } @@ -214,6 +214,7 @@ int uv_shutdown(uv_shutdown_t* req, uv_stream_t* handle, uv_shutdown_cb cb) { req->cb = cb; handle->flags &= ~UV_HANDLE_WRITABLE; + handle->flags |= UV_HANDLE_SHUTTING; handle->stream.conn.shutdown_req = req; handle->reqs_pending++; REGISTER_HANDLE_REQ(loop, handle, req); diff --git a/src/win/tcp.c b/src/win/tcp.c index 187f36e..b6aa4c5 100644 --- a/src/win/tcp.c +++ b/src/win/tcp.c @@ -29,6 +29,14 @@ #include "req-inl.h" +/* + * Threshold of active tcp streams for which to preallocate tcp read buffers. + * (Due to node slab allocator performing poorly under this pattern, + * the optimization is temporarily disabled (threshold=0). This will be + * revisited once node allocator is improved.) + */ +const unsigned int uv_active_tcp_streams_threshold = 0; + /* * Number of simultaneous pending AcceptEx calls. */ @@ -175,14 +183,14 @@ int uv_tcp_init_ex(uv_loop_t* loop, uv_tcp_t* handle, unsigned int flags) { sock = socket(domain, SOCK_STREAM, 0); if (sock == INVALID_SOCKET) { err = WSAGetLastError(); - uv__queue_remove(&handle->handle_queue); + QUEUE_REMOVE(&handle->handle_queue); return uv_translate_sys_error(err); } err = uv__tcp_set_socket(handle->loop, handle, sock, domain, 0); if (err) { closesocket(sock); - uv__queue_remove(&handle->handle_queue); + QUEUE_REMOVE(&handle->handle_queue); return uv_translate_sys_error(err); } @@ -206,6 +214,7 @@ void uv__process_tcp_shutdown_req(uv_loop_t* loop, uv_tcp_t* stream, uv_shutdown assert(stream->flags & UV_HANDLE_CONNECTION); stream->stream.conn.shutdown_req = NULL; + stream->flags &= ~UV_HANDLE_SHUTTING; UNREGISTER_HANDLE_REQ(loop, stream, req); err = 0; @@ -265,6 +274,7 @@ void uv__tcp_endgame(uv_loop_t* loop, uv_tcp_t* handle) { } uv__handle_close(handle); + loop->active_tcp_streams--; } @@ -474,9 +484,26 @@ static void uv__tcp_queue_read(uv_loop_t* loop, uv_tcp_t* handle) { req = &handle->read_req; memset(&req->u.io.overlapped, 0, sizeof(req->u.io.overlapped)); - handle->flags |= UV_HANDLE_ZERO_READ; - buf.base = (char*) &uv_zero_; - buf.len = 0; + /* + * Preallocate a read buffer if the number of active streams is below + * the threshold. + */ + if (loop->active_tcp_streams < uv_active_tcp_streams_threshold) { + handle->flags &= ~UV_HANDLE_ZERO_READ; + handle->tcp.conn.read_buffer = uv_buf_init(NULL, 0); + handle->alloc_cb((uv_handle_t*) handle, 65536, &handle->tcp.conn.read_buffer); + if (handle->tcp.conn.read_buffer.base == NULL || + handle->tcp.conn.read_buffer.len == 0) { + handle->read_cb((uv_stream_t*) handle, UV_ENOBUFS, &handle->tcp.conn.read_buffer); + return; + } + assert(handle->tcp.conn.read_buffer.base != NULL); + buf = handle->tcp.conn.read_buffer; + } else { + handle->flags |= UV_HANDLE_ZERO_READ; + buf.base = (char*) &uv_zero_; + buf.len = 0; + } /* Prepare the overlapped structure. */ memset(&(req->u.io.overlapped), 0, sizeof(req->u.io.overlapped)); @@ -523,7 +550,7 @@ int uv_tcp_close_reset(uv_tcp_t* handle, uv_close_cb close_cb) { struct linger l = { 1, 0 }; /* Disallow setting SO_LINGER to zero due to some platform inconsistencies */ - if (uv__is_stream_shutting(handle)) + if (handle->flags & UV_HANDLE_SHUTTING) return UV_EINVAL; if (0 != setsockopt(handle->socket, SOL_SOCKET, SO_LINGER, (const char*)&l, sizeof(l))) @@ -627,6 +654,7 @@ int uv__tcp_listen(uv_tcp_t* handle, int backlog, uv_connection_cb cb) { int uv__tcp_accept(uv_tcp_t* server, uv_tcp_t* client) { + uv_loop_t* loop = server->loop; int err = 0; int family; @@ -688,6 +716,8 @@ int uv__tcp_accept(uv_tcp_t* server, uv_tcp_t* client) { } } + loop->active_tcp_streams++; + return err; } @@ -1133,7 +1163,7 @@ void uv__process_tcp_write_req(uv_loop_t* loop, uv_tcp_t* handle, closesocket(handle->socket); handle->socket = INVALID_SOCKET; } - if (uv__is_stream_shutting(handle)) + if (handle->flags & UV_HANDLE_SHUTTING) uv__process_tcp_shutdown_req(loop, handle, handle->stream.conn.shutdown_req); @@ -1218,6 +1248,7 @@ void uv__process_tcp_connect_req(uv_loop_t* loop, uv_tcp_t* handle, 0) == 0) { uv__connection_init((uv_stream_t*)handle); handle->flags |= UV_HANDLE_READABLE | UV_HANDLE_WRITABLE; + loop->active_tcp_streams++; } else { err = WSAGetLastError(); } @@ -1300,6 +1331,7 @@ int uv__tcp_xfer_import(uv_tcp_t* tcp, tcp->flags |= UV_HANDLE_READABLE | UV_HANDLE_WRITABLE; } + tcp->loop->active_tcp_streams++; return 0; } @@ -1400,7 +1432,7 @@ static void uv__tcp_try_cancel_reqs(uv_tcp_t* tcp) { uv_tcp_non_ifs_lsp_ipv4; /* If there are non-ifs LSPs then try to obtain a base handle for the socket. - */ + * This will always fail on Windows XP/3k. */ if (non_ifs_lsp) { DWORD bytes; if (WSAIoctl(socket, diff --git a/src/win/thread.c b/src/win/thread.c index 57c25e8..d3b1c96 100644 --- a/src/win/thread.c +++ b/src/win/thread.c @@ -180,81 +180,6 @@ int uv_thread_create_ex(uv_thread_t* tid, return UV_EIO; } -int uv_thread_setaffinity(uv_thread_t* tid, - char* cpumask, - char* oldmask, - size_t mask_size) { - int i; - HANDLE hproc; - DWORD_PTR procmask; - DWORD_PTR sysmask; - DWORD_PTR threadmask; - DWORD_PTR oldthreadmask; - int cpumasksize; - - cpumasksize = uv_cpumask_size(); - assert(cpumasksize > 0); - if (mask_size < (size_t)cpumasksize) - return UV_EINVAL; - - hproc = GetCurrentProcess(); - if (!GetProcessAffinityMask(hproc, &procmask, &sysmask)) - return uv_translate_sys_error(GetLastError()); - - threadmask = 0; - for (i = 0; i < cpumasksize; i++) { - if (cpumask[i]) { - if (procmask & (1 << i)) - threadmask |= 1 << i; - else - return UV_EINVAL; - } - } - - oldthreadmask = SetThreadAffinityMask(*tid, threadmask); - if (oldthreadmask == 0) - return uv_translate_sys_error(GetLastError()); - - if (oldmask != NULL) { - for (i = 0; i < cpumasksize; i++) - oldmask[i] = (oldthreadmask >> i) & 1; - } - - return 0; -} - -int uv_thread_getaffinity(uv_thread_t* tid, - char* cpumask, - size_t mask_size) { - int i; - HANDLE hproc; - DWORD_PTR procmask; - DWORD_PTR sysmask; - DWORD_PTR threadmask; - int cpumasksize; - - cpumasksize = uv_cpumask_size(); - assert(cpumasksize > 0); - if (mask_size < (size_t)cpumasksize) - return UV_EINVAL; - - hproc = GetCurrentProcess(); - if (!GetProcessAffinityMask(hproc, &procmask, &sysmask)) - return uv_translate_sys_error(GetLastError()); - - threadmask = SetThreadAffinityMask(*tid, procmask); - if (threadmask == 0 || SetThreadAffinityMask(*tid, threadmask) == 0) - return uv_translate_sys_error(GetLastError()); - - for (i = 0; i < cpumasksize; i++) - cpumask[i] = (threadmask >> i) & 1; - - return 0; -} - -int uv_thread_getcpu(void) { - return GetCurrentProcessorNumber(); -} uv_thread_t uv_thread_self(void) { uv_thread_t key; @@ -449,7 +374,6 @@ void uv_cond_wait(uv_cond_t* cond, uv_mutex_t* mutex) { abort(); } - int uv_cond_timedwait(uv_cond_t* cond, uv_mutex_t* mutex, uint64_t timeout) { if (SleepConditionVariableCS(&cond->cond_var, mutex, (DWORD)(timeout / 1e6))) return 0; @@ -459,6 +383,69 @@ int uv_cond_timedwait(uv_cond_t* cond, uv_mutex_t* mutex, uint64_t timeout) { } +int uv_barrier_init(uv_barrier_t* barrier, unsigned int count) { + int err; + + barrier->n = count; + barrier->count = 0; + + err = uv_mutex_init(&barrier->mutex); + if (err) + return err; + + err = uv_sem_init(&barrier->turnstile1, 0); + if (err) + goto error2; + + err = uv_sem_init(&barrier->turnstile2, 1); + if (err) + goto error; + + return 0; + +error: + uv_sem_destroy(&barrier->turnstile1); +error2: + uv_mutex_destroy(&barrier->mutex); + return err; + +} + + +void uv_barrier_destroy(uv_barrier_t* barrier) { + uv_sem_destroy(&barrier->turnstile2); + uv_sem_destroy(&barrier->turnstile1); + uv_mutex_destroy(&barrier->mutex); +} + + +int uv_barrier_wait(uv_barrier_t* barrier) { + int serial_thread; + + uv_mutex_lock(&barrier->mutex); + if (++barrier->count == barrier->n) { + uv_sem_wait(&barrier->turnstile2); + uv_sem_post(&barrier->turnstile1); + } + uv_mutex_unlock(&barrier->mutex); + + uv_sem_wait(&barrier->turnstile1); + uv_sem_post(&barrier->turnstile1); + + uv_mutex_lock(&barrier->mutex); + serial_thread = (--barrier->count == 0); + if (serial_thread) { + uv_sem_wait(&barrier->turnstile1); + uv_sem_post(&barrier->turnstile2); + } + uv_mutex_unlock(&barrier->mutex); + + uv_sem_wait(&barrier->turnstile2); + uv_sem_post(&barrier->turnstile2); + return serial_thread; +} + + int uv_key_create(uv_key_t* key) { key->tls_index = TlsAlloc(); if (key->tls_index == TLS_OUT_OF_INDEXES) diff --git a/src/win/tty.c b/src/win/tty.c index 9f8dd69..267ca64 100644 --- a/src/win/tty.c +++ b/src/win/tty.c @@ -23,7 +23,12 @@ #include #include #include -#include + +#if defined(_MSC_VER) && _MSC_VER < 1600 +# include "uv/stdint-msvc2008.h" +#else +# include +#endif #ifndef COMMON_LVB_REVERSE_VIDEO # define COMMON_LVB_REVERSE_VIDEO 0x4000 @@ -170,14 +175,14 @@ void uv__console_init(void) { 0); if (uv__tty_console_handle != INVALID_HANDLE_VALUE) { CONSOLE_SCREEN_BUFFER_INFO sb_info; + QueueUserWorkItem(uv__tty_console_resize_message_loop_thread, + NULL, + WT_EXECUTELONGFUNCTION); uv_mutex_init(&uv__tty_console_resize_mutex); if (GetConsoleScreenBufferInfo(uv__tty_console_handle, &sb_info)) { uv__tty_console_width = sb_info.dwSize.X; uv__tty_console_height = sb_info.srWindow.Bottom - sb_info.srWindow.Top + 1; } - QueueUserWorkItem(uv__tty_console_resize_message_loop_thread, - NULL, - WT_EXECUTELONGFUNCTION); } } @@ -482,11 +487,9 @@ static DWORD CALLBACK uv_tty_line_read_thread(void* data) { uv_loop_t* loop; uv_tty_t* handle; uv_req_t* req; - DWORD bytes; - size_t read_bytes; + DWORD bytes, read_bytes; WCHAR utf16[MAX_INPUT_BUFFER_LENGTH / 3]; - DWORD chars; - DWORD read_chars; + DWORD chars, read_chars; LONG status; COORD pos; BOOL read_console_success; @@ -527,13 +530,16 @@ static DWORD CALLBACK uv_tty_line_read_thread(void* data) { NULL); if (read_console_success) { - read_bytes = bytes; - uv_utf16_to_wtf8(utf16, - read_chars, - &handle->tty.rd.read_line_buffer.base, - &read_bytes); + read_bytes = WideCharToMultiByte(CP_UTF8, + 0, + utf16, + read_chars, + handle->tty.rd.read_line_buffer.base, + bytes, + NULL, + NULL); SET_REQ_SUCCESS(req); - req->u.io.overlapped.InternalHigh = (DWORD) read_bytes; + req->u.io.overlapped.InternalHigh = read_bytes; } else { SET_REQ_ERROR(req, GetLastError()); } @@ -695,7 +701,7 @@ void uv_process_tty_read_raw_req(uv_loop_t* loop, uv_tty_t* handle, DWORD records_left, records_read; uv_buf_t buf; - _off_t buf_used; + off_t buf_used; assert(handle->type == UV_TTY); assert(handle->flags & UV_HANDLE_TTY_READABLE); @@ -797,9 +803,7 @@ void uv_process_tty_read_raw_req(uv_loop_t* loop, uv_tty_t* handle, } if (KEV.uChar.UnicodeChar != 0) { - int prefix_len; - size_t char_len; - char* last_key_buf; + int prefix_len, char_len; /* Character key pressed */ if (KEV.uChar.UnicodeChar >= 0xD800 && @@ -820,31 +824,38 @@ void uv_process_tty_read_raw_req(uv_loop_t* loop, uv_tty_t* handle, prefix_len = 0; } - char_len = sizeof handle->tty.rd.last_key; - last_key_buf = &handle->tty.rd.last_key[prefix_len]; - if (handle->tty.rd.last_utf16_high_surrogate) { + if (KEV.uChar.UnicodeChar >= 0xDC00 && + KEV.uChar.UnicodeChar < 0xE000) { /* UTF-16 surrogate pair */ WCHAR utf16_buffer[2]; utf16_buffer[0] = handle->tty.rd.last_utf16_high_surrogate; utf16_buffer[1] = KEV.uChar.UnicodeChar; - if (uv_utf16_to_wtf8(utf16_buffer, - 2, - &last_key_buf, - &char_len)) - char_len = 0; - handle->tty.rd.last_utf16_high_surrogate = 0; + char_len = WideCharToMultiByte(CP_UTF8, + 0, + utf16_buffer, + 2, + &handle->tty.rd.last_key[prefix_len], + sizeof handle->tty.rd.last_key, + NULL, + NULL); } else { /* Single UTF-16 character */ - if (uv_utf16_to_wtf8(&KEV.uChar.UnicodeChar, - 1, - &last_key_buf, - &char_len)) - char_len = 0; + char_len = WideCharToMultiByte(CP_UTF8, + 0, + &KEV.uChar.UnicodeChar, + 1, + &handle->tty.rd.last_key[prefix_len], + sizeof handle->tty.rd.last_key, + NULL, + NULL); } + /* Whatever happened, the last character wasn't a high surrogate. */ + handle->tty.rd.last_utf16_high_surrogate = 0; + /* If the utf16 character(s) couldn't be converted something must be * wrong. */ - if (char_len == 0) { + if (!char_len) { handle->flags &= ~UV_HANDLE_READING; DECREASE_ACTIVE_COUNT(loop, handle); handle->read_cb((uv_stream_t*) handle, @@ -2228,11 +2239,11 @@ void uv__process_tty_write_req(uv_loop_t* loop, uv_tty_t* handle, handle->stream.conn.write_reqs_pending--; - if (handle->stream.conn.write_reqs_pending == 0 && - uv__is_stream_shutting(handle)) - uv__process_tty_shutdown_req(loop, - handle, - handle->stream.conn.shutdown_req); + if (handle->stream.conn.write_reqs_pending == 0) + if (handle->flags & UV_HANDLE_SHUTTING) + uv__process_tty_shutdown_req(loop, + handle, + handle->stream.conn.shutdown_req); DECREASE_PENDING_REQ_COUNT(handle); } @@ -2246,7 +2257,7 @@ void uv__tty_close(uv_tty_t* handle) { if (handle->u.fd == -1) CloseHandle(handle->handle); else - _close(handle->u.fd); + close(handle->u.fd); handle->u.fd = -1; handle->handle = INVALID_HANDLE_VALUE; @@ -2263,6 +2274,7 @@ void uv__process_tty_shutdown_req(uv_loop_t* loop, uv_tty_t* stream, uv_shutdown assert(req); stream->stream.conn.shutdown_req = NULL; + stream->flags &= ~UV_HANDLE_SHUTTING; UNREGISTER_HANDLE_REQ(loop, stream, req); /* TTY shutdown is really just a no-op */ @@ -2292,6 +2304,26 @@ void uv__tty_endgame(uv_loop_t* loop, uv_tty_t* handle) { } +/* + * uv__process_tty_accept_req() is a stub to keep DELEGATE_STREAM_REQ working + * TODO: find a way to remove it + */ +void uv__process_tty_accept_req(uv_loop_t* loop, uv_tty_t* handle, + uv_req_t* raw_req) { + abort(); +} + + +/* + * uv__process_tty_connect_req() is a stub to keep DELEGATE_STREAM_REQ working + * TODO: find a way to remove it + */ +void uv__process_tty_connect_req(uv_loop_t* loop, uv_tty_t* handle, + uv_connect_t* req) { + abort(); +} + + int uv_tty_reset_mode(void) { /* Not necessary to do anything. */ return 0; @@ -2397,6 +2429,7 @@ static void uv__tty_console_signal_resize(void) { height = sb_info.srWindow.Bottom - sb_info.srWindow.Top + 1; uv_mutex_lock(&uv__tty_console_resize_mutex); + assert(uv__tty_console_width != -1 && uv__tty_console_height != -1); if (width != uv__tty_console_width || height != uv__tty_console_height) { uv__tty_console_width = width; uv__tty_console_height = height; diff --git a/src/win/udp.c b/src/win/udp.c index eab5384..eaebc1e 100644 --- a/src/win/udp.c +++ b/src/win/udp.c @@ -29,6 +29,11 @@ #include "req-inl.h" +/* + * Threshold of active udp streams for which to preallocate udp read buffers. + */ +const unsigned int uv_active_udp_streams_threshold = 0; + /* A zero-size buffer for use by uv_udp_read */ static char uv_zero_[] = ""; int uv_udp_getpeername(const uv_udp_t* handle, @@ -146,14 +151,14 @@ int uv__udp_init_ex(uv_loop_t* loop, sock = socket(domain, SOCK_DGRAM, 0); if (sock == INVALID_SOCKET) { err = WSAGetLastError(); - uv__queue_remove(&handle->handle_queue); + QUEUE_REMOVE(&handle->handle_queue); return uv_translate_sys_error(err); } err = uv__udp_set_socket(handle->loop, handle, sock, domain); if (err) { closesocket(sock); - uv__queue_remove(&handle->handle_queue); + QUEUE_REMOVE(&handle->handle_queue); return uv_translate_sys_error(err); } } @@ -271,35 +276,84 @@ static void uv__udp_queue_recv(uv_loop_t* loop, uv_udp_t* handle) { req = &handle->recv_req; memset(&req->u.io.overlapped, 0, sizeof(req->u.io.overlapped)); - handle->flags |= UV_HANDLE_ZERO_READ; - - buf.base = (char*) uv_zero_; - buf.len = 0; - flags = MSG_PEEK; - - result = handle->func_wsarecv(handle->socket, - (WSABUF*) &buf, - 1, - &bytes, - &flags, - &req->u.io.overlapped, - NULL); + /* + * Preallocate a read buffer if the number of active streams is below + * the threshold. + */ + if (loop->active_udp_streams < uv_active_udp_streams_threshold) { + handle->flags &= ~UV_HANDLE_ZERO_READ; + + handle->recv_buffer = uv_buf_init(NULL, 0); + handle->alloc_cb((uv_handle_t*) handle, UV__UDP_DGRAM_MAXSIZE, &handle->recv_buffer); + if (handle->recv_buffer.base == NULL || handle->recv_buffer.len == 0) { + handle->recv_cb(handle, UV_ENOBUFS, &handle->recv_buffer, NULL, 0); + return; + } + assert(handle->recv_buffer.base != NULL); + + buf = handle->recv_buffer; + memset(&handle->recv_from, 0, sizeof handle->recv_from); + handle->recv_from_len = sizeof handle->recv_from; + flags = 0; + + result = handle->func_wsarecvfrom(handle->socket, + (WSABUF*) &buf, + 1, + &bytes, + &flags, + (struct sockaddr*) &handle->recv_from, + &handle->recv_from_len, + &req->u.io.overlapped, + NULL); + + if (UV_SUCCEEDED_WITHOUT_IOCP(result == 0)) { + /* Process the req without IOCP. */ + handle->flags |= UV_HANDLE_READ_PENDING; + req->u.io.overlapped.InternalHigh = bytes; + handle->reqs_pending++; + uv__insert_pending_req(loop, req); + } else if (UV_SUCCEEDED_WITH_IOCP(result == 0)) { + /* The req will be processed with IOCP. */ + handle->flags |= UV_HANDLE_READ_PENDING; + handle->reqs_pending++; + } else { + /* Make this req pending reporting an error. */ + SET_REQ_ERROR(req, WSAGetLastError()); + uv__insert_pending_req(loop, req); + handle->reqs_pending++; + } - if (UV_SUCCEEDED_WITHOUT_IOCP(result == 0)) { - /* Process the req without IOCP. */ - handle->flags |= UV_HANDLE_READ_PENDING; - req->u.io.overlapped.InternalHigh = bytes; - handle->reqs_pending++; - uv__insert_pending_req(loop, req); - } else if (UV_SUCCEEDED_WITH_IOCP(result == 0)) { - /* The req will be processed with IOCP. */ - handle->flags |= UV_HANDLE_READ_PENDING; - handle->reqs_pending++; } else { - /* Make this req pending reporting an error. */ - SET_REQ_ERROR(req, WSAGetLastError()); - uv__insert_pending_req(loop, req); - handle->reqs_pending++; + handle->flags |= UV_HANDLE_ZERO_READ; + + buf.base = (char*) uv_zero_; + buf.len = 0; + flags = MSG_PEEK; + + result = handle->func_wsarecv(handle->socket, + (WSABUF*) &buf, + 1, + &bytes, + &flags, + &req->u.io.overlapped, + NULL); + + if (UV_SUCCEEDED_WITHOUT_IOCP(result == 0)) { + /* Process the req without IOCP. */ + handle->flags |= UV_HANDLE_READ_PENDING; + req->u.io.overlapped.InternalHigh = bytes; + handle->reqs_pending++; + uv__insert_pending_req(loop, req); + } else if (UV_SUCCEEDED_WITH_IOCP(result == 0)) { + /* The req will be processed with IOCP. */ + handle->flags |= UV_HANDLE_READ_PENDING; + handle->reqs_pending++; + } else { + /* Make this req pending reporting an error. */ + SET_REQ_ERROR(req, WSAGetLastError()); + uv__insert_pending_req(loop, req); + handle->reqs_pending++; + } } } @@ -322,6 +376,7 @@ int uv__udp_recv_start(uv_udp_t* handle, uv_alloc_cb alloc_cb, handle->flags |= UV_HANDLE_READING; INCREASE_ACTIVE_COUNT(loop, handle); + loop->active_udp_streams++; handle->recv_cb = recv_cb; handle->alloc_cb = alloc_cb; @@ -338,6 +393,7 @@ int uv__udp_recv_start(uv_udp_t* handle, uv_alloc_cb alloc_cb, int uv__udp_recv_stop(uv_udp_t* handle) { if (handle->flags & UV_HANDLE_READING) { handle->flags &= ~UV_HANDLE_READING; + handle->loop->active_udp_streams--; DECREASE_ACTIVE_COUNT(loop, handle); } @@ -441,68 +497,57 @@ void uv__process_udp_recv_req(uv_loop_t* loop, uv_udp_t* handle, DWORD bytes, err, flags; struct sockaddr_storage from; int from_len; - int count; - - /* Prevent loop starvation when the data comes in as fast as - * (or faster than) we can read it. */ - count = 32; - - do { - /* Do at most `count` nonblocking receive. */ - buf = uv_buf_init(NULL, 0); - handle->alloc_cb((uv_handle_t*) handle, UV__UDP_DGRAM_MAXSIZE, &buf); - if (buf.base == NULL || buf.len == 0) { - handle->recv_cb(handle, UV_ENOBUFS, &buf, NULL, 0); - goto done; - } - memset(&from, 0, sizeof from); - from_len = sizeof from; + /* Do a nonblocking receive. + * TODO: try to read multiple datagrams at once. FIONREAD maybe? */ + buf = uv_buf_init(NULL, 0); + handle->alloc_cb((uv_handle_t*) handle, UV__UDP_DGRAM_MAXSIZE, &buf); + if (buf.base == NULL || buf.len == 0) { + handle->recv_cb(handle, UV_ENOBUFS, &buf, NULL, 0); + goto done; + } + assert(buf.base != NULL); - flags = 0; + memset(&from, 0, sizeof from); + from_len = sizeof from; - if (WSARecvFrom(handle->socket, - (WSABUF*)&buf, - 1, - &bytes, - &flags, - (struct sockaddr*) &from, - &from_len, - NULL, - NULL) != SOCKET_ERROR) { + flags = 0; - /* Message received */ - err = ERROR_SUCCESS; - handle->recv_cb(handle, bytes, &buf, (const struct sockaddr*) &from, 0); + if (WSARecvFrom(handle->socket, + (WSABUF*)&buf, + 1, + &bytes, + &flags, + (struct sockaddr*) &from, + &from_len, + NULL, + NULL) != SOCKET_ERROR) { + + /* Message received */ + handle->recv_cb(handle, bytes, &buf, (const struct sockaddr*) &from, 0); + } else { + err = WSAGetLastError(); + if (err == WSAEMSGSIZE) { + /* Message truncated */ + handle->recv_cb(handle, + bytes, + &buf, + (const struct sockaddr*) &from, + UV_UDP_PARTIAL); + } else if (err == WSAEWOULDBLOCK) { + /* Kernel buffer empty */ + handle->recv_cb(handle, 0, &buf, NULL, 0); + } else if (err == WSAECONNRESET || err == WSAENETRESET) { + /* WSAECONNRESET/WSANETRESET is ignored because this just indicates + * that a previous sendto operation failed. + */ + handle->recv_cb(handle, 0, &buf, NULL, 0); } else { - err = WSAGetLastError(); - if (err == WSAEMSGSIZE) { - /* Message truncated */ - handle->recv_cb(handle, - bytes, - &buf, - (const struct sockaddr*) &from, - UV_UDP_PARTIAL); - } else if (err == WSAEWOULDBLOCK) { - /* Kernel buffer empty */ - handle->recv_cb(handle, 0, &buf, NULL, 0); - } else if (err == WSAECONNRESET || err == WSAENETRESET) { - /* WSAECONNRESET/WSANETRESET is ignored because this just indicates - * that a previous sendto operation failed. - */ - handle->recv_cb(handle, 0, &buf, NULL, 0); - } else { - /* Any other error that we want to report back to the user. */ - uv_udp_recv_stop(handle); - handle->recv_cb(handle, uv_translate_sys_error(err), &buf, NULL, 0); - } + /* Any other error that we want to report back to the user. */ + uv_udp_recv_stop(handle); + handle->recv_cb(handle, uv_translate_sys_error(err), &buf, NULL, 0); } } - while (err == ERROR_SUCCESS && - count-- > 0 && - /* The recv_cb callback may decide to pause or close the handle. */ - (handle->flags & UV_HANDLE_READING) && - !(handle->flags & UV_HANDLE_READ_PENDING)); } done: diff --git a/src/win/util.c b/src/win/util.c index a96cb91..9943205 100644 --- a/src/win/util.c +++ b/src/win/util.c @@ -31,7 +31,6 @@ #include "internal.h" /* clang-format off */ -#include #include #include #include @@ -95,7 +94,7 @@ void uv__util_init(void) { int uv_exepath(char* buffer, size_t* size_ptr) { - size_t utf8_len, utf16_buffer_len, utf16_len; + int utf8_len, utf16_buffer_len, utf16_len; WCHAR* utf16_buffer; int err; @@ -122,18 +121,29 @@ int uv_exepath(char* buffer, size_t* size_ptr) { goto error; } + /* utf16_len contains the length, *not* including the terminating null. */ + utf16_buffer[utf16_len] = L'\0'; + /* Convert to UTF-8 */ - utf8_len = *size_ptr - 1; /* Reserve space for NUL */ - err = uv_utf16_to_wtf8(utf16_buffer, utf16_len, &buffer, &utf8_len); - if (err == UV_ENOBUFS) { - utf8_len = *size_ptr - 1; - err = 0; + utf8_len = WideCharToMultiByte(CP_UTF8, + 0, + utf16_buffer, + -1, + buffer, + (int) *size_ptr, + NULL, + NULL); + if (utf8_len == 0) { + err = GetLastError(); + goto error; } - *size_ptr = utf8_len; uv__free(utf16_buffer); - return err; + /* utf8_len *does* include the terminating null at this point, but the + * returned size shouldn't. */ + *size_ptr = utf8_len - 1; + return 0; error: uv__free(utf16_buffer); @@ -141,51 +151,6 @@ int uv_exepath(char* buffer, size_t* size_ptr) { } -static int uv__cwd(WCHAR** buf, DWORD *len) { - WCHAR* p; - DWORD n; - DWORD t; - - t = GetCurrentDirectoryW(0, NULL); - for (;;) { - if (t == 0) - return uv_translate_sys_error(GetLastError()); - - /* |t| is the size of the buffer _including_ nul. */ - p = uv__malloc(t * sizeof(*p)); - if (p == NULL) - return UV_ENOMEM; - - /* |n| is the size of the buffer _excluding_ nul but _only on success_. - * If |t| was too small because another thread changed the working - * directory, |n| is the size the buffer should be _including_ nul. - * It therefore follows we must resize when n >= t and fail when n == 0. - */ - n = GetCurrentDirectoryW(t, p); - if (n > 0) - if (n < t) - break; - - uv__free(p); - t = n; - } - - /* The returned directory should not have a trailing slash, unless it points - * at a drive root, like c:\. Remove it if needed. - */ - t = n - 1; - if (p[t] == L'\\' && !(n == 3 && p[1] == L':')) { - p[t] = L'\0'; - n = t; - } - - *buf = p; - *len = n; - - return 0; -} - - int uv_cwd(char* buffer, size_t* size) { DWORD utf16_len; WCHAR *utf16_buffer; @@ -195,50 +160,134 @@ int uv_cwd(char* buffer, size_t* size) { return UV_EINVAL; } - r = uv__cwd(&utf16_buffer, &utf16_len); - if (r < 0) - return r; + utf16_len = GetCurrentDirectoryW(0, NULL); + if (utf16_len == 0) { + return uv_translate_sys_error(GetLastError()); + } + utf16_buffer = uv__malloc(utf16_len * sizeof(WCHAR)); + if (utf16_buffer == NULL) { + return UV_ENOMEM; + } + + utf16_len = GetCurrentDirectoryW(utf16_len, utf16_buffer); + if (utf16_len == 0) { + uv__free(utf16_buffer); + return uv_translate_sys_error(GetLastError()); + } + + /* utf16_len contains the length, *not* including the terminating null. */ + utf16_buffer[utf16_len] = L'\0'; + + /* The returned directory should not have a trailing slash, unless it points + * at a drive root, like c:\. Remove it if needed. */ + if (utf16_buffer[utf16_len - 1] == L'\\' && + !(utf16_len == 3 && utf16_buffer[1] == L':')) { + utf16_len--; + utf16_buffer[utf16_len] = L'\0'; + } - r = uv__copy_utf16_to_utf8(utf16_buffer, utf16_len, buffer, size); + /* Check how much space we need */ + r = WideCharToMultiByte(CP_UTF8, + 0, + utf16_buffer, + -1, + NULL, + 0, + NULL, + NULL); + if (r == 0) { + uv__free(utf16_buffer); + return uv_translate_sys_error(GetLastError()); + } else if (r > (int) *size) { + uv__free(utf16_buffer); + *size = r; + return UV_ENOBUFS; + } + /* Convert to UTF-8 */ + r = WideCharToMultiByte(CP_UTF8, + 0, + utf16_buffer, + -1, + buffer, + *size > INT_MAX ? INT_MAX : (int) *size, + NULL, + NULL); uv__free(utf16_buffer); - return r; + if (r == 0) { + return uv_translate_sys_error(GetLastError()); + } + + *size = r - 1; + return 0; } int uv_chdir(const char* dir) { WCHAR *utf16_buffer; - DWORD utf16_len; + size_t utf16_len, new_utf16_len; WCHAR drive_letter, env_var[4]; - int r; - /* Convert to UTF-16 */ - r = uv__convert_utf8_to_utf16(dir, &utf16_buffer); - if (r) - return r; + if (dir == NULL) { + return UV_EINVAL; + } - if (!SetCurrentDirectoryW(utf16_buffer)) { + utf16_len = MultiByteToWideChar(CP_UTF8, + 0, + dir, + -1, + NULL, + 0); + if (utf16_len == 0) { + return uv_translate_sys_error(GetLastError()); + } + utf16_buffer = uv__malloc(utf16_len * sizeof(WCHAR)); + if (utf16_buffer == NULL) { + return UV_ENOMEM; + } + + if (MultiByteToWideChar(CP_UTF8, + 0, + dir, + -1, + utf16_buffer, + utf16_len) == 0) { uv__free(utf16_buffer); return uv_translate_sys_error(GetLastError()); } - /* uv__cwd() will return a new buffer. */ - uv__free(utf16_buffer); - utf16_buffer = NULL; + if (!SetCurrentDirectoryW(utf16_buffer)) { + uv__free(utf16_buffer); + return uv_translate_sys_error(GetLastError()); + } /* Windows stores the drive-local path in an "hidden" environment variable, * which has the form "=C:=C:\Windows". SetCurrentDirectory does not update * this, so we'll have to do it. */ - r = uv__cwd(&utf16_buffer, &utf16_len); - if (r == UV_ENOMEM) { - /* When updating the environment variable fails, return UV_OK anyway. - * We did successfully change current working directory, only updating - * hidden env variable failed. */ + new_utf16_len = GetCurrentDirectoryW(utf16_len, utf16_buffer); + if (new_utf16_len > utf16_len ) { + uv__free(utf16_buffer); + utf16_buffer = uv__malloc(new_utf16_len * sizeof(WCHAR)); + if (utf16_buffer == NULL) { + /* When updating the environment variable fails, return UV_OK anyway. + * We did successfully change current working directory, only updating + * hidden env variable failed. */ + return 0; + } + new_utf16_len = GetCurrentDirectoryW(new_utf16_len, utf16_buffer); + } + if (utf16_len == 0) { + uv__free(utf16_buffer); return 0; } - if (r < 0) { - return r; + + /* The returned directory should not have a trailing slash, unless it points + * at a drive root, like c:\. Remove it if needed. */ + if (utf16_buffer[utf16_len - 1] == L'\\' && + !(utf16_len == 3 && utf16_buffer[1] == L':')) { + utf16_len--; + utf16_buffer[utf16_len] = L'\0'; } if (utf16_len < 2 || utf16_buffer[1] != L':') { @@ -281,7 +330,7 @@ uint64_t uv_get_free_memory(void) { memory_status.dwLength = sizeof(memory_status); if (!GlobalMemoryStatusEx(&memory_status)) { - return 0; + return -1; } return (uint64_t)memory_status.ullAvailPhys; @@ -293,7 +342,7 @@ uint64_t uv_get_total_memory(void) { memory_status.dwLength = sizeof(memory_status); if (!GlobalMemoryStatusEx(&memory_status)) { - return 0; + return -1; } return (uint64_t)memory_status.ullTotalPhys; @@ -305,11 +354,6 @@ uint64_t uv_get_constrained_memory(void) { } -uint64_t uv_get_available_memory(void) { - return uv_get_free_memory(); -} - - uv_pid_t uv_os_getpid(void) { return GetCurrentProcessId(); } @@ -354,14 +398,29 @@ int uv_set_process_title(const char* title) { uv__once_init(); - err = uv__convert_utf8_to_utf16(title, &title_w); - if (err) - return err; + /* Find out how big the buffer for the wide-char title must be */ + length = MultiByteToWideChar(CP_UTF8, 0, title, -1, NULL, 0); + if (!length) { + err = GetLastError(); + goto done; + } + + /* Convert to wide-char string */ + title_w = (WCHAR*)uv__malloc(sizeof(WCHAR) * length); + if (!title_w) { + uv_fatal_error(ERROR_OUTOFMEMORY, "uv__malloc"); + } + + length = MultiByteToWideChar(CP_UTF8, 0, title, -1, title_w, length); + if (!length) { + err = GetLastError(); + goto done; + } /* If the title must be truncated insert a \0 terminator there */ - length = wcslen(title_w); - if (length >= MAX_TITLE_LENGTH) + if (length > MAX_TITLE_LENGTH) { title_w[MAX_TITLE_LENGTH - 1] = L'\0'; + } if (!SetConsoleTitleW(title_w)) { err = GetLastError(); @@ -383,19 +442,20 @@ done: static int uv__get_process_title(void) { WCHAR title_w[MAX_TITLE_LENGTH]; - DWORD wlen; - wlen = GetConsoleTitleW(title_w, sizeof(title_w) / sizeof(WCHAR)); - if (wlen == 0) - return uv_translate_sys_error(GetLastError()); + if (!GetConsoleTitleW(title_w, sizeof(title_w) / sizeof(WCHAR))) { + return -1; + } - return uv__convert_utf16_to_utf8(title_w, wlen, &process_title); + if (uv__convert_utf16_to_utf8(title_w, -1, &process_title) != 0) + return -1; + + return 0; } int uv_get_process_title(char* buffer, size_t size) { size_t len; - int r; if (buffer == NULL || size == 0) return UV_EINVAL; @@ -407,12 +467,9 @@ int uv_get_process_title(char* buffer, size_t size) { * If the process_title was never read before nor explicitly set, * we must query it with getConsoleTitleW */ - if (process_title == NULL) { - r = uv__get_process_title(); - if (r) { - LeaveCriticalSection(&process_title_lock); - return r; - } + if (!process_title && uv__get_process_title() == -1) { + LeaveCriticalSection(&process_title_lock); + return uv_translate_sys_error(GetLastError()); } assert(process_title); @@ -430,43 +487,11 @@ int uv_get_process_title(char* buffer, size_t size) { } -/* https://github.com/libuv/libuv/issues/1674 */ -int uv_clock_gettime(uv_clock_id clock_id, uv_timespec64_t* ts) { - FILETIME ft; - int64_t t; - - if (ts == NULL) - return UV_EFAULT; - - switch (clock_id) { - case UV_CLOCK_MONOTONIC: - uv__once_init(); - t = uv__hrtime(UV__NANOSEC); - ts->tv_sec = t / 1000000000; - ts->tv_nsec = t % 1000000000; - return 0; - case UV_CLOCK_REALTIME: - GetSystemTimePreciseAsFileTime(&ft); - /* In 100-nanosecond increments from 1601-01-01 UTC because why not? */ - t = (int64_t) ft.dwHighDateTime << 32 | ft.dwLowDateTime; - /* Convert to UNIX epoch, 1970-01-01. Still in 100 ns increments. */ - t -= 116444736000000000ll; - /* Now convert to seconds and nanoseconds. */ - ts->tv_sec = t / 10000000; - ts->tv_nsec = t % 10000000 * 100; - return 0; - } - - return UV_EINVAL; -} - - uint64_t uv_hrtime(void) { uv__once_init(); return uv__hrtime(UV__NANOSEC); } - uint64_t uv__hrtime(unsigned int scale) { LARGE_INTEGER counter; double scaled_freq; @@ -653,6 +678,71 @@ int uv_cpu_info(uv_cpu_info_t** cpu_infos_ptr, int* cpu_count_ptr) { } +static int is_windows_version_or_greater(DWORD os_major, + DWORD os_minor, + WORD service_pack_major, + WORD service_pack_minor) { + OSVERSIONINFOEX osvi; + DWORDLONG condition_mask = 0; + int op = VER_GREATER_EQUAL; + + /* Initialize the OSVERSIONINFOEX structure. */ + ZeroMemory(&osvi, sizeof(OSVERSIONINFOEX)); + osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX); + osvi.dwMajorVersion = os_major; + osvi.dwMinorVersion = os_minor; + osvi.wServicePackMajor = service_pack_major; + osvi.wServicePackMinor = service_pack_minor; + + /* Initialize the condition mask. */ + VER_SET_CONDITION(condition_mask, VER_MAJORVERSION, op); + VER_SET_CONDITION(condition_mask, VER_MINORVERSION, op); + VER_SET_CONDITION(condition_mask, VER_SERVICEPACKMAJOR, op); + VER_SET_CONDITION(condition_mask, VER_SERVICEPACKMINOR, op); + + /* Perform the test. */ + return (int) VerifyVersionInfo( + &osvi, + VER_MAJORVERSION | VER_MINORVERSION | + VER_SERVICEPACKMAJOR | VER_SERVICEPACKMINOR, + condition_mask); +} + + +static int address_prefix_match(int family, + struct sockaddr* address, + struct sockaddr* prefix_address, + int prefix_len) { + uint8_t* address_data; + uint8_t* prefix_address_data; + int i; + + assert(address->sa_family == family); + assert(prefix_address->sa_family == family); + + if (family == AF_INET6) { + address_data = (uint8_t*) &(((struct sockaddr_in6 *) address)->sin6_addr); + prefix_address_data = + (uint8_t*) &(((struct sockaddr_in6 *) prefix_address)->sin6_addr); + } else { + address_data = (uint8_t*) &(((struct sockaddr_in *) address)->sin_addr); + prefix_address_data = + (uint8_t*) &(((struct sockaddr_in *) prefix_address)->sin_addr); + } + + for (i = 0; i < prefix_len >> 3; i++) { + if (address_data[i] != prefix_address_data[i]) + return 0; + } + + if (prefix_len % 8) + return prefix_address_data[i] == + (address_data[i] & (0xff << (8 - prefix_len % 8))); + + return 1; +} + + int uv_interface_addresses(uv_interface_address_t** addresses_ptr, int* count_ptr) { IP_ADAPTER_ADDRESSES* win_address_buf; @@ -665,13 +755,26 @@ int uv_interface_addresses(uv_interface_address_t** addresses_ptr, uv_interface_address_t* uv_address; int count; + + int is_vista_or_greater; ULONG flags; *addresses_ptr = NULL; *count_ptr = 0; - flags = GAA_FLAG_SKIP_ANYCAST | GAA_FLAG_SKIP_MULTICAST | - GAA_FLAG_SKIP_DNS_SERVER; + is_vista_or_greater = is_windows_version_or_greater(6, 0, 0, 0); + if (is_vista_or_greater) { + flags = GAA_FLAG_SKIP_ANYCAST | GAA_FLAG_SKIP_MULTICAST | + GAA_FLAG_SKIP_DNS_SERVER; + } else { + /* We need at least XP SP1. */ + if (!is_windows_version_or_greater(5, 1, 1, 0)) + return UV_ENOTSUP; + + flags = GAA_FLAG_SKIP_ANYCAST | GAA_FLAG_SKIP_MULTICAST | + GAA_FLAG_SKIP_DNS_SERVER | GAA_FLAG_INCLUDE_PREFIX; + } + /* Fetch the size of the adapters reported by windows, and then get the list * itself. */ @@ -758,8 +861,19 @@ int uv_interface_addresses(uv_interface_address_t** addresses_ptr, continue; /* Compute the size of the interface name. */ - name_size = uv_utf16_length_as_wtf8(adapter->FriendlyName, -1); - uv_address_buf_size += name_size + 1; + name_size = WideCharToMultiByte(CP_UTF8, + 0, + adapter->FriendlyName, + -1, + NULL, + 0, + NULL, + FALSE); + if (name_size <= 0) { + uv__free(win_address_buf); + return uv_translate_sys_error(GetLastError()); + } + uv_address_buf_size += name_size; /* Count the number of addresses associated with this interface, and * compute the size. */ @@ -789,25 +903,30 @@ int uv_interface_addresses(uv_interface_address_t** addresses_ptr, adapter != NULL; adapter = adapter->Next) { IP_ADAPTER_UNICAST_ADDRESS* unicast_address; - size_t name_size; - int r; + int name_size; + size_t max_name_size; if (adapter->OperStatus != IfOperStatusUp || adapter->FirstUnicastAddress == NULL) continue; /* Convert the interface name to UTF8. */ - name_size = (char*) uv_address_buf + uv_address_buf_size - name_buf; - r = uv__copy_utf16_to_utf8(adapter->FriendlyName, - -1, - name_buf, - &name_size); - if (r) { + max_name_size = (char*) uv_address_buf + uv_address_buf_size - name_buf; + if (max_name_size > (size_t) INT_MAX) + max_name_size = INT_MAX; + name_size = WideCharToMultiByte(CP_UTF8, + 0, + adapter->FriendlyName, + -1, + name_buf, + (int) max_name_size, + NULL, + FALSE); + if (name_size <= 0) { uv__free(win_address_buf); uv__free(uv_address_buf); - return r; + return uv_translate_sys_error(GetLastError()); } - name_size += 1; /* Add NUL byte. */ /* Add an uv_interface_address_t element for every unicast address. */ for (unicast_address = (IP_ADAPTER_UNICAST_ADDRESS*) @@ -819,8 +938,37 @@ int uv_interface_addresses(uv_interface_address_t** addresses_ptr, sa = unicast_address->Address.lpSockaddr; - prefix_len = - ((IP_ADAPTER_UNICAST_ADDRESS_LH*) unicast_address)->OnLinkPrefixLength; + /* XP has no OnLinkPrefixLength field. */ + if (is_vista_or_greater) { + prefix_len = + ((IP_ADAPTER_UNICAST_ADDRESS_LH*) unicast_address)->OnLinkPrefixLength; + } else { + /* Prior to Windows Vista the FirstPrefix pointed to the list with + * single prefix for each IP address assigned to the adapter. + * Order of FirstPrefix does not match order of FirstUnicastAddress, + * so we need to find corresponding prefix. + */ + IP_ADAPTER_PREFIX* prefix; + prefix_len = 0; + + for (prefix = adapter->FirstPrefix; prefix; prefix = prefix->Next) { + /* We want the longest matching prefix. */ + if (prefix->Address.lpSockaddr->sa_family != sa->sa_family || + prefix->PrefixLength <= prefix_len) + continue; + + if (address_prefix_match(sa->sa_family, sa, + prefix->Address.lpSockaddr, prefix->PrefixLength)) { + prefix_len = prefix->PrefixLength; + } + } + + /* If there is no matching prefix information, return a single-host + * subnet mask (e.g. 255.255.255.255 for IPv4). + */ + if (!prefix_len) + prefix_len = (sa->sa_family == AF_INET6) ? 128 : 32; + } memset(uv_address, 0, sizeof *uv_address); @@ -945,8 +1093,8 @@ int uv_os_homedir(char* buffer, size_t* size) { if (r != UV_ENOENT) return r; - /* USERPROFILE is not set, so call uv_os_get_passwd() */ - r = uv_os_get_passwd(&pwd); + /* USERPROFILE is not set, so call uv__getpwuid_r() */ + r = uv__getpwuid_r(&pwd); if (r != 0) { return r; @@ -970,6 +1118,7 @@ int uv_os_homedir(char* buffer, size_t* size) { int uv_os_tmpdir(char* buffer, size_t* size) { wchar_t *path; + DWORD bufsize; size_t len; if (buffer == NULL || size == NULL || *size == 0) @@ -986,7 +1135,7 @@ int uv_os_tmpdir(char* buffer, size_t* size) { if (path == NULL) { return UV_ENOMEM; } - len = GetTempPathW(len, path); + len = GetTempPathW(len, path); if (len == 0) { uv__free(path); @@ -1001,7 +1150,45 @@ int uv_os_tmpdir(char* buffer, size_t* size) { path[len] = L'\0'; } - return uv__copy_utf16_to_utf8(path, len, buffer, size); + /* Check how much space we need */ + bufsize = WideCharToMultiByte(CP_UTF8, 0, path, -1, NULL, 0, NULL, NULL); + + if (bufsize == 0) { + uv__free(path); + return uv_translate_sys_error(GetLastError()); + } else if (bufsize > *size) { + uv__free(path); + *size = bufsize; + return UV_ENOBUFS; + } + + /* Convert to UTF-8 */ + bufsize = WideCharToMultiByte(CP_UTF8, + 0, + path, + -1, + buffer, + *size, + NULL, + NULL); + uv__free(path); + + if (bufsize == 0) + return uv_translate_sys_error(GetLastError()); + + *size = bufsize - 1; + return 0; +} + + +void uv_os_free_passwd(uv_passwd_t* pwd) { + if (pwd == NULL) + return; + + uv__free(pwd->username); + uv__free(pwd->homedir); + pwd->username = NULL; + pwd->homedir = NULL; } @@ -1012,72 +1199,96 @@ int uv_os_tmpdir(char* buffer, size_t* size) { * If utf16 is null terminated, utf16len can be set to -1, otherwise it must * be specified. */ -int uv__convert_utf16_to_utf8(const WCHAR* utf16, size_t utf16len, char** utf8) { - size_t utf8_len = 0; +int uv__convert_utf16_to_utf8(const WCHAR* utf16, int utf16len, char** utf8) { + DWORD bufsize; if (utf16 == NULL) return UV_EINVAL; - *utf8 = NULL; - return uv_utf16_to_wtf8(utf16, utf16len, utf8, &utf8_len); + /* Check how much space we need */ + bufsize = WideCharToMultiByte(CP_UTF8, + 0, + utf16, + utf16len, + NULL, + 0, + NULL, + NULL); + + if (bufsize == 0) + return uv_translate_sys_error(GetLastError()); + + /* Allocate the destination buffer adding an extra byte for the terminating + * NULL. If utf16len is not -1 WideCharToMultiByte will not add it, so + * we do it ourselves always, just in case. */ + *utf8 = uv__malloc(bufsize + 1); + + if (*utf8 == NULL) + return UV_ENOMEM; + + /* Convert to UTF-8 */ + bufsize = WideCharToMultiByte(CP_UTF8, + 0, + utf16, + utf16len, + *utf8, + bufsize, + NULL, + NULL); + + if (bufsize == 0) { + uv__free(*utf8); + *utf8 = NULL; + return uv_translate_sys_error(GetLastError()); + } + + (*utf8)[bufsize] = '\0'; + return 0; } /* * Converts a UTF-8 string into a UTF-16 one. The resulting string is * null-terminated. + * + * If utf8 is null terminated, utf8len can be set to -1, otherwise it must + * be specified. */ -int uv__convert_utf8_to_utf16(const char* utf8, WCHAR** utf16) { +int uv__convert_utf8_to_utf16(const char* utf8, int utf8len, WCHAR** utf16) { int bufsize; if (utf8 == NULL) return UV_EINVAL; - /* Check how much space we need (including NUL). */ - bufsize = uv_wtf8_length_as_utf16(utf8); - if (bufsize < 0) - return UV__EINVAL; + /* Check how much space we need */ + bufsize = MultiByteToWideChar(CP_UTF8, 0, utf8, utf8len, NULL, 0); + + if (bufsize == 0) + return uv_translate_sys_error(GetLastError()); - /* Allocate the destination buffer. */ - *utf16 = uv__malloc(sizeof(WCHAR) * bufsize); + /* Allocate the destination buffer adding an extra byte for the terminating + * NULL. If utf8len is not -1 MultiByteToWideChar will not add it, so + * we do it ourselves always, just in case. */ + *utf16 = uv__malloc(sizeof(WCHAR) * (bufsize + 1)); if (*utf16 == NULL) return UV_ENOMEM; /* Convert to UTF-16 */ - uv_wtf8_to_utf16(utf8, *utf16, bufsize); - - return 0; -} - - -/* - * Converts a UTF-16 string into a UTF-8 one in an existing buffer. The - * resulting string is null-terminated. - * - * If utf16 is null terminated, utf16len can be set to -1, otherwise it must - * be specified. - */ -int uv__copy_utf16_to_utf8(const WCHAR* utf16buffer, size_t utf16len, char* utf8, size_t *size) { - int r; + bufsize = MultiByteToWideChar(CP_UTF8, 0, utf8, utf8len, *utf16, bufsize); - if (utf8 == NULL || size == NULL) - return UV_EINVAL; - - if (*size == 0) { - *size = uv_utf16_length_as_wtf8(utf16buffer, utf16len); - r = UV_ENOBUFS; - } else { - *size -= 1; /* Reserve space for NUL. */ - r = uv_utf16_to_wtf8(utf16buffer, utf16len, &utf8, size); + if (bufsize == 0) { + uv__free(*utf16); + *utf16 = NULL; + return uv_translate_sys_error(GetLastError()); } - if (r == UV_ENOBUFS) - *size += 1; /* Add space for NUL. */ - return r; + + (*utf16)[bufsize] = L'\0'; + return 0; } -static int uv__getpwuid_r(uv_passwd_t* pwd) { +int uv__getpwuid_r(uv_passwd_t* pwd) { HANDLE token; wchar_t username[UNLEN + 1]; wchar_t *path; @@ -1155,16 +1366,6 @@ int uv_os_get_passwd(uv_passwd_t* pwd) { } -int uv_os_get_passwd2(uv_passwd_t* pwd, uv_uid_t uid) { - return UV_ENOTSUP; -} - - -int uv_os_get_group(uv_group_t* grp, uv_uid_t gid) { - return UV_ENOTSUP; -} - - int uv_os_environ(uv_env_item_t** envitems, int* count) { wchar_t* env; wchar_t* penv; @@ -1241,13 +1442,14 @@ int uv_os_getenv(const char* name, char* buffer, size_t* size) { wchar_t* var; DWORD varlen; wchar_t* name_w; + DWORD bufsize; size_t len; int r; if (name == NULL || buffer == NULL || size == NULL || *size == 0) return UV_EINVAL; - r = uv__convert_utf8_to_utf16(name, &name_w); + r = uv__convert_utf8_to_utf16(name, -1, &name_w); if (r != 0) return r; @@ -1288,7 +1490,35 @@ int uv_os_getenv(const char* name, char* buffer, size_t* size) { } } - r = uv__copy_utf16_to_utf8(var, len, buffer, size); + /* Check how much space we need */ + bufsize = WideCharToMultiByte(CP_UTF8, 0, var, -1, NULL, 0, NULL, NULL); + + if (bufsize == 0) { + r = uv_translate_sys_error(GetLastError()); + goto fail; + } else if (bufsize > *size) { + *size = bufsize; + r = UV_ENOBUFS; + goto fail; + } + + /* Convert to UTF-8 */ + bufsize = WideCharToMultiByte(CP_UTF8, + 0, + var, + -1, + buffer, + *size, + NULL, + NULL); + + if (bufsize == 0) { + r = uv_translate_sys_error(GetLastError()); + goto fail; + } + + *size = bufsize - 1; + r = 0; fail: @@ -1310,12 +1540,12 @@ int uv_os_setenv(const char* name, const char* value) { if (name == NULL || value == NULL) return UV_EINVAL; - r = uv__convert_utf8_to_utf16(name, &name_w); + r = uv__convert_utf8_to_utf16(name, -1, &name_w); if (r != 0) return r; - r = uv__convert_utf8_to_utf16(value, &value_w); + r = uv__convert_utf8_to_utf16(value, -1, &value_w); if (r != 0) { uv__free(name_w); @@ -1340,7 +1570,7 @@ int uv_os_unsetenv(const char* name) { if (name == NULL) return UV_EINVAL; - r = uv__convert_utf8_to_utf16(name, &name_w); + r = uv__convert_utf8_to_utf16(name, -1, &name_w); if (r != 0) return r; @@ -1357,6 +1587,9 @@ int uv_os_unsetenv(const char* name) { int uv_os_gethostname(char* buffer, size_t* size) { WCHAR buf[UV_MAXHOSTNAMESIZE]; + size_t len; + char* utf8_str; + int convert_result; if (buffer == NULL || size == NULL || *size == 0) return UV_EINVAL; @@ -1369,7 +1602,22 @@ int uv_os_gethostname(char* buffer, size_t* size) { if (pGetHostNameW(buf, UV_MAXHOSTNAMESIZE) != 0) return uv_translate_sys_error(WSAGetLastError()); - return uv__copy_utf16_to_utf8(buf, -1, buffer, size); + convert_result = uv__convert_utf16_to_utf8(buf, -1, &utf8_str); + + if (convert_result != 0) + return convert_result; + + len = strlen(utf8_str); + if (len >= *size) { + *size = len + 1; + uv__free(utf8_str); + return UV_ENOBUFS; + } + + memcpy(buffer, utf8_str, len + 1); + uv__free(utf8_str); + *size = len; + return 0; } @@ -1466,48 +1714,6 @@ int uv_os_setpriority(uv_pid_t pid, int priority) { return r; } -int uv_thread_getpriority(uv_thread_t tid, int* priority) { - int r; - - if (priority == NULL) - return UV_EINVAL; - - r = GetThreadPriority(tid); - if (r == THREAD_PRIORITY_ERROR_RETURN) - return uv_translate_sys_error(GetLastError()); - - *priority = r; - return 0; -} - -int uv_thread_setpriority(uv_thread_t tid, int priority) { - int r; - - switch (priority) { - case UV_THREAD_PRIORITY_HIGHEST: - r = SetThreadPriority(tid, THREAD_PRIORITY_HIGHEST); - break; - case UV_THREAD_PRIORITY_ABOVE_NORMAL: - r = SetThreadPriority(tid, THREAD_PRIORITY_ABOVE_NORMAL); - break; - case UV_THREAD_PRIORITY_NORMAL: - r = SetThreadPriority(tid, THREAD_PRIORITY_NORMAL); - break; - case UV_THREAD_PRIORITY_BELOW_NORMAL: - r = SetThreadPriority(tid, THREAD_PRIORITY_BELOW_NORMAL); - break; - case UV_THREAD_PRIORITY_LOWEST: - r = SetThreadPriority(tid, THREAD_PRIORITY_LOWEST); - break; - default: - return 0; - } - - if (r == 0) - return uv_translate_sys_error(GetLastError()); - - return 0; -} int uv_os_uname(uv_utsname_t* buffer) { /* Implementation loosely based on @@ -1517,7 +1723,7 @@ int uv_os_uname(uv_utsname_t* buffer) { HKEY registry_key; WCHAR product_name_w[256]; DWORD product_name_w_size; - size_t version_size; + int version_size; int processor_level; int r; @@ -1548,7 +1754,7 @@ int uv_os_uname(uv_utsname_t* buffer) { r = RegOpenKeyExW(HKEY_LOCAL_MACHINE, L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion", 0, - KEY_QUERY_VALUE | KEY_WOW64_64KEY, + KEY_QUERY_VALUE, ®istry_key); if (r == ERROR_SUCCESS) { @@ -1563,45 +1769,37 @@ int uv_os_uname(uv_utsname_t* buffer) { RegCloseKey(registry_key); if (r == ERROR_SUCCESS) { - /* Windows 11 shares dwMajorVersion with Windows 10 - * this workaround tries to disambiguate that by checking - * if the dwBuildNumber is from Windows 11 releases (>= 22000). - * - * This workaround replaces the ProductName key value - * from "Windows 10 *" to "Windows 11 *" */ - if (os_info.dwMajorVersion == 10 && - os_info.dwBuildNumber >= 22000 && - product_name_w_size >= ARRAY_SIZE(L"Windows 10")) { - /* If ProductName starts with "Windows 10" */ - if (wcsncmp(product_name_w, L"Windows 10", ARRAY_SIZE(L"Windows 10") - 1) == 0) { - /* Bump 10 to 11 */ - product_name_w[9] = '1'; - } - } - - version_size = sizeof(buffer->version); - r = uv__copy_utf16_to_utf8(product_name_w, - -1, - buffer->version, - &version_size); - if (r) + version_size = WideCharToMultiByte(CP_UTF8, + 0, + product_name_w, + -1, + buffer->version, + sizeof(buffer->version), + NULL, + NULL); + if (version_size == 0) { + r = uv_translate_sys_error(GetLastError()); goto error; + } } } /* Append service pack information to the version if present. */ if (os_info.szCSDVersion[0] != L'\0') { if (version_size > 0) - buffer->version[version_size++] = ' '; - - version_size = sizeof(buffer->version) - version_size; - r = uv__copy_utf16_to_utf8(os_info.szCSDVersion, - -1, - buffer->version + - sizeof(buffer->version) - version_size, - &version_size); - if (r) + buffer->version[version_size - 1] = ' '; + + if (WideCharToMultiByte(CP_UTF8, + 0, + os_info.szCSDVersion, + -1, + buffer->version + version_size, + sizeof(buffer->version) - version_size, + NULL, + NULL) == 0) { + r = uv_translate_sys_error(GetLastError()); goto error; + } } /* Populate the sysname field. */ diff --git a/test/benchmark-async-pummel.c b/test/benchmark-async-pummel.c index 68864c8..49660a6 100644 --- a/test/benchmark-async-pummel.c +++ b/test/benchmark-async-pummel.c @@ -62,7 +62,6 @@ static void pummel(void* arg) { static int test_async_pummel(int nthreads) { - char fmtbuf[2][32]; uv_thread_t* tids; uv_async_t handle; uint64_t time; @@ -71,31 +70,31 @@ static int test_async_pummel(int nthreads) { tids = calloc(nthreads, sizeof(tids[0])); ASSERT_NOT_NULL(tids); - ASSERT_OK(uv_async_init(uv_default_loop(), &handle, async_cb)); + ASSERT(0 == uv_async_init(uv_default_loop(), &handle, async_cb)); ACCESS_ONCE(const char*, handle.data) = running; for (i = 0; i < nthreads; i++) - ASSERT_OK(uv_thread_create(tids + i, pummel, &handle)); + ASSERT(0 == uv_thread_create(tids + i, pummel, &handle)); time = uv_hrtime(); - ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT)); + ASSERT(0 == uv_run(uv_default_loop(), UV_RUN_DEFAULT)); time = uv_hrtime() - time; done = 1; for (i = 0; i < nthreads; i++) - ASSERT_OK(uv_thread_join(tids + i)); + ASSERT(0 == uv_thread_join(tids + i)); printf("async_pummel_%d: %s callbacks in %.2f seconds (%s/sec)\n", nthreads, - fmt(&fmtbuf[0], callbacks), + fmt(callbacks), time / 1e9, - fmt(&fmtbuf[1], callbacks / (time / 1e9))); + fmt(callbacks / (time / 1e9))); free(tids); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/benchmark-async.c b/test/benchmark-async.c index 5544c46..5167ecb 100644 --- a/test/benchmark-async.c +++ b/test/benchmark-async.c @@ -43,7 +43,7 @@ struct ctx { static void worker_async_cb(uv_async_t* handle) { struct ctx* ctx = container_of(handle, struct ctx, worker_async); - ASSERT_OK(uv_async_send(&ctx->main_async)); + ASSERT(0 == uv_async_send(&ctx->main_async)); ctx->worker_sent++; ctx->worker_seen++; @@ -55,7 +55,7 @@ static void worker_async_cb(uv_async_t* handle) { static void main_async_cb(uv_async_t* handle) { struct ctx* ctx = container_of(handle, struct ctx, main_async); - ASSERT_OK(uv_async_send(&ctx->worker_async)); + ASSERT(0 == uv_async_send(&ctx->worker_async)); ctx->main_sent++; ctx->main_seen++; @@ -66,14 +66,13 @@ static void main_async_cb(uv_async_t* handle) { static void worker(void* arg) { struct ctx* ctx = arg; - ASSERT_OK(uv_async_send(&ctx->main_async)); - ASSERT_OK(uv_run(&ctx->loop, UV_RUN_DEFAULT)); + ASSERT(0 == uv_async_send(&ctx->main_async)); + ASSERT(0 == uv_run(&ctx->loop, UV_RUN_DEFAULT)); uv_loop_close(&ctx->loop); } static int test_async(int nthreads) { - char fmtbuf[32]; struct ctx* threads; struct ctx* ctx; uint64_t time; @@ -85,39 +84,39 @@ static int test_async(int nthreads) { for (i = 0; i < nthreads; i++) { ctx = threads + i; ctx->nthreads = nthreads; - ASSERT_OK(uv_loop_init(&ctx->loop)); - ASSERT_OK(uv_async_init(&ctx->loop, &ctx->worker_async, worker_async_cb)); - ASSERT_OK(uv_async_init(uv_default_loop(), - &ctx->main_async, - main_async_cb)); - ASSERT_OK(uv_thread_create(&ctx->thread, worker, ctx)); + ASSERT(0 == uv_loop_init(&ctx->loop)); + ASSERT(0 == uv_async_init(&ctx->loop, &ctx->worker_async, worker_async_cb)); + ASSERT(0 == uv_async_init(uv_default_loop(), + &ctx->main_async, + main_async_cb)); + ASSERT(0 == uv_thread_create(&ctx->thread, worker, ctx)); } time = uv_hrtime(); - ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT)); + ASSERT(0 == uv_run(uv_default_loop(), UV_RUN_DEFAULT)); for (i = 0; i < nthreads; i++) - ASSERT_OK(uv_thread_join(&threads[i].thread)); + ASSERT(0 == uv_thread_join(&threads[i].thread)); time = uv_hrtime() - time; for (i = 0; i < nthreads; i++) { ctx = threads + i; - ASSERT_EQ(ctx->worker_sent, NUM_PINGS); - ASSERT_EQ(ctx->worker_seen, NUM_PINGS); - ASSERT_EQ(ctx->main_sent, (unsigned int) NUM_PINGS); - ASSERT_EQ(ctx->main_seen, (unsigned int) NUM_PINGS); + ASSERT(ctx->worker_sent == NUM_PINGS); + ASSERT(ctx->worker_seen == NUM_PINGS); + ASSERT(ctx->main_sent == (unsigned int) NUM_PINGS); + ASSERT(ctx->main_seen == (unsigned int) NUM_PINGS); } printf("async%d: %.2f sec (%s/sec)\n", nthreads, time / 1e9, - fmt(&fmtbuf, NUM_PINGS / (time / 1e9))); + fmt(NUM_PINGS / (time / 1e9))); free(threads); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/benchmark-fs-stat.c b/test/benchmark-fs-stat.c index c410622..32d2589 100644 --- a/test/benchmark-fs-stat.c +++ b/test/benchmark-fs-stat.c @@ -60,7 +60,6 @@ static void warmup(const char* path) { static void sync_bench(const char* path) { - char fmtbuf[2][32]; uint64_t before; uint64_t after; uv_fs_t req; @@ -75,9 +74,9 @@ static void sync_bench(const char* path) { after = uv_hrtime(); printf("%s stats (sync): %.2fs (%s/s)\n", - fmt(&fmtbuf[0], 1.0 * NUM_SYNC_REQS), + fmt(1.0 * NUM_SYNC_REQS), (after - before) / 1e9, - fmt(&fmtbuf[1], (1.0 * NUM_SYNC_REQS) / ((after - before) / 1e9))); + fmt((1.0 * NUM_SYNC_REQS) / ((after - before) / 1e9))); fflush(stdout); } @@ -94,7 +93,6 @@ static void stat_cb(uv_fs_t* fs_req) { static void async_bench(const char* path) { struct async_req reqs[MAX_CONCURRENT_REQS]; struct async_req* req; - char fmtbuf[2][32]; uint64_t before; uint64_t after; int count; @@ -114,10 +112,10 @@ static void async_bench(const char* path) { after = uv_hrtime(); printf("%s stats (%d concurrent): %.2fs (%s/s)\n", - fmt(&fmtbuf[0], 1.0 * NUM_ASYNC_REQS), + fmt(1.0 * NUM_ASYNC_REQS), i, (after - before) / 1e9, - fmt(&fmtbuf[1], (1.0 * NUM_ASYNC_REQS) / ((after - before) / 1e9))); + fmt((1.0 * NUM_ASYNC_REQS) / ((after - before) / 1e9))); fflush(stdout); } } @@ -133,6 +131,6 @@ BENCHMARK_IMPL(fs_stat) { warmup(path); sync_bench(path); async_bench(path); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/benchmark-getaddrinfo.c b/test/benchmark-getaddrinfo.c index cb4d2bc..1dbc23d 100644 --- a/test/benchmark-getaddrinfo.c +++ b/test/benchmark-getaddrinfo.c @@ -43,7 +43,7 @@ static void getaddrinfo_initiate(uv_getaddrinfo_t* handle); static void getaddrinfo_cb(uv_getaddrinfo_t* handle, int status, struct addrinfo* res) { - ASSERT_OK(status); + ASSERT(status == 0); calls_completed++; if (calls_initiated < TOTAL_CALLS) { getaddrinfo_initiate(handle); @@ -59,7 +59,7 @@ static void getaddrinfo_initiate(uv_getaddrinfo_t* handle) { calls_initiated++; r = uv_getaddrinfo(loop, handle, &getaddrinfo_cb, name, NULL, NULL); - ASSERT_OK(r); + ASSERT(r == 0); } @@ -80,13 +80,13 @@ BENCHMARK_IMPL(getaddrinfo) { uv_update_time(loop); end_time = uv_now(loop); - ASSERT_EQ(calls_initiated, TOTAL_CALLS); - ASSERT_EQ(calls_completed, TOTAL_CALLS); + ASSERT(calls_initiated == TOTAL_CALLS); + ASSERT(calls_completed == TOTAL_CALLS); fprintf(stderr, "getaddrinfo: %.0f req/s\n", (double) calls_completed / (double) (end_time - start_time) * 1000.0); fflush(stderr); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/benchmark-list.h b/test/benchmark-list.h index 901e5ff..1ab8f25 100644 --- a/test/benchmark-list.h +++ b/test/benchmark-list.h @@ -22,7 +22,6 @@ BENCHMARK_DECLARE (sizes) BENCHMARK_DECLARE (loop_count) BENCHMARK_DECLARE (loop_count_timed) -BENCHMARK_DECLARE (loop_alive) BENCHMARK_DECLARE (ping_pongs) BENCHMARK_DECLARE (ping_udp1) BENCHMARK_DECLARE (ping_udp10) @@ -90,7 +89,6 @@ TASK_LIST_START BENCHMARK_ENTRY (sizes) BENCHMARK_ENTRY (loop_count) BENCHMARK_ENTRY (loop_count_timed) - BENCHMARK_ENTRY (loop_alive) BENCHMARK_ENTRY (ping_pongs) BENCHMARK_HELPER (ping_pongs, tcp4_echo_server) diff --git a/test/benchmark-loop-count.c b/test/benchmark-loop-count.c index 0db4aa5..970a94c 100644 --- a/test/benchmark-loop-count.c +++ b/test/benchmark-loop-count.c @@ -26,7 +26,6 @@ #include #define NUM_TICKS (2 * 1000 * 1000) -#define NUM_TICKS2 (2 * 1000 * 1000 * 100) static unsigned long ticks; static uv_idle_t idle_handle; @@ -38,19 +37,6 @@ static void idle_cb(uv_idle_t* handle) { uv_idle_stop(handle); } -static void idle_alive_cb(uv_idle_t* handle) { - int ticks = 0; - - while (++ticks < NUM_TICKS2) { - int r = uv_loop_alive(handle->loop); - if (r == 0) - abort(); - } - - *(int*)handle->data = ticks; - uv_idle_stop(handle); -} - static void idle2_cb(uv_idle_t* handle) { ticks++; @@ -74,7 +60,7 @@ BENCHMARK_IMPL(loop_count) { uv_run(loop, UV_RUN_DEFAULT); ns = uv_hrtime() - ns; - ASSERT_UINT64_EQ(ticks, NUM_TICKS); + ASSERT(ticks == NUM_TICKS); fprintf(stderr, "loop_count: %d ticks in %.2fs (%.0f/s)\n", NUM_TICKS, @@ -82,7 +68,7 @@ BENCHMARK_IMPL(loop_count) { NUM_TICKS / (ns / 1e9)); fflush(stderr); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -101,34 +87,6 @@ BENCHMARK_IMPL(loop_count_timed) { fprintf(stderr, "loop_count: %lu ticks (%.0f ticks/s)\n", ticks, ticks / 5.0); fflush(stderr); - MAKE_VALGRIND_HAPPY(loop); - return 0; -} - -/* Measure the performance of running uv_loop_alive(). Adding this so we can get - * some sort of metric for the impact of switching active_reqs.count to use - * atomics. No other code sits in a hot path. */ -BENCHMARK_IMPL(loop_alive) { - uv_loop_t* loop = uv_default_loop(); - int ticks = 0; - uint64_t ns; - - uv_idle_init(loop, &idle_handle); - idle_handle.data = &ticks; - uv_idle_start(&idle_handle, idle_alive_cb); - - ns = uv_hrtime(); - uv_run(loop, UV_RUN_DEFAULT); - ns = uv_hrtime() - ns; - - ASSERT_EQ(ticks, NUM_TICKS2); - - fprintf(stderr, "loop_alive: %d ticks in %.2fs (%.0f/s)\n", - NUM_TICKS2, - ns / 1e9, - NUM_TICKS2 / (ns / 1e9)); - fflush(stderr); - - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/benchmark-million-async.c b/test/benchmark-million-async.c index 13b52d4..937a12f 100644 --- a/test/benchmark-million-async.c +++ b/test/benchmark-million-async.c @@ -60,7 +60,7 @@ static void timer_cb(uv_timer_t* handle) { unsigned i; done = 1; - ASSERT_OK(uv_thread_join(&thread_id)); + ASSERT(0 == uv_thread_join(&thread_id)); for (i = 0; i < ARRAY_SIZE(container->async_handles); i++) { uv_async_t* handle = container->async_handles + i; @@ -76,7 +76,6 @@ static void timer_cb(uv_timer_t* handle) { BENCHMARK_IMPL(million_async) { - char fmtbuf[3][32]; uv_timer_t timer_handle; uv_async_t* handle; uv_loop_t* loop; @@ -93,21 +92,21 @@ BENCHMARK_IMPL(million_async) { for (i = 0; i < ARRAY_SIZE(container->async_handles); i++) { handle = container->async_handles + i; - ASSERT_OK(uv_async_init(loop, handle, async_cb)); + ASSERT(0 == uv_async_init(loop, handle, async_cb)); handle->data = NULL; } - ASSERT_OK(uv_timer_init(loop, &timer_handle)); - ASSERT_OK(uv_timer_start(&timer_handle, timer_cb, timeout, 0)); - ASSERT_OK(uv_thread_create(&thread_id, thread_cb, NULL)); - ASSERT_OK(uv_run(loop, UV_RUN_DEFAULT)); + ASSERT(0 == uv_timer_init(loop, &timer_handle)); + ASSERT(0 == uv_timer_start(&timer_handle, timer_cb, timeout, 0)); + ASSERT(0 == uv_thread_create(&thread_id, thread_cb, NULL)); + ASSERT(0 == uv_run(loop, UV_RUN_DEFAULT)); printf("%s async events in %.1f seconds (%s/s, %s unique handles seen)\n", - fmt(&fmtbuf[0], container->async_events), + fmt(container->async_events), timeout / 1000., - fmt(&fmtbuf[1], container->async_events / (timeout / 1000.)), - fmt(&fmtbuf[2], container->handles_seen)); + fmt(container->async_events / (timeout / 1000.)), + fmt(container->handles_seen)); free(container); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/benchmark-million-timers.c b/test/benchmark-million-timers.c index fd999c4..ef25c20 100644 --- a/test/benchmark-million-timers.c +++ b/test/benchmark-million-timers.c @@ -57,22 +57,22 @@ BENCHMARK_IMPL(million_timers) { before_all = uv_hrtime(); for (i = 0; i < NUM_TIMERS; i++) { if (i % 1000 == 0) timeout++; - ASSERT_OK(uv_timer_init(loop, timers + i)); - ASSERT_OK(uv_timer_start(timers + i, timer_cb, timeout, 0)); + ASSERT(0 == uv_timer_init(loop, timers + i)); + ASSERT(0 == uv_timer_start(timers + i, timer_cb, timeout, 0)); } before_run = uv_hrtime(); - ASSERT_OK(uv_run(loop, UV_RUN_DEFAULT)); + ASSERT(0 == uv_run(loop, UV_RUN_DEFAULT)); after_run = uv_hrtime(); for (i = 0; i < NUM_TIMERS; i++) uv_close((uv_handle_t*) (timers + i), close_cb); - ASSERT_OK(uv_run(loop, UV_RUN_DEFAULT)); + ASSERT(0 == uv_run(loop, UV_RUN_DEFAULT)); after_all = uv_hrtime(); - ASSERT_EQ(timer_cb_called, NUM_TIMERS); - ASSERT_EQ(close_cb_called, NUM_TIMERS); + ASSERT(timer_cb_called == NUM_TIMERS); + ASSERT(close_cb_called == NUM_TIMERS); free(timers); fprintf(stderr, "%.2f seconds total\n", (after_all - before_all) / 1e9); @@ -81,6 +81,6 @@ BENCHMARK_IMPL(million_timers) { fprintf(stderr, "%.2f seconds cleanup\n", (after_all - after_run) / 1e9); fflush(stderr); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/benchmark-multi-accept.c b/test/benchmark-multi-accept.c index 1d19e33..86b7da5 100644 --- a/test/benchmark-multi-accept.c +++ b/test/benchmark-multi-accept.c @@ -117,19 +117,19 @@ static void ipc_connection_cb(uv_stream_t* ipc_pipe, int status) { ASSERT_NOT_NULL(pc); if (ipc_pipe->type == UV_TCP) - ASSERT_OK(uv_tcp_init(loop, (uv_tcp_t*) &pc->peer_handle)); + ASSERT(0 == uv_tcp_init(loop, (uv_tcp_t*) &pc->peer_handle)); else if (ipc_pipe->type == UV_NAMED_PIPE) - ASSERT_OK(uv_pipe_init(loop, (uv_pipe_t*) &pc->peer_handle, 1)); + ASSERT(0 == uv_pipe_init(loop, (uv_pipe_t*) &pc->peer_handle, 1)); else ASSERT(0); - ASSERT_OK(uv_accept(ipc_pipe, (uv_stream_t*) &pc->peer_handle)); - ASSERT_OK(uv_write2(&pc->write_req, - (uv_stream_t*) &pc->peer_handle, - &buf, - 1, - (uv_stream_t*) &sc->server_handle, - ipc_write_cb)); + ASSERT(0 == uv_accept(ipc_pipe, (uv_stream_t*) &pc->peer_handle)); + ASSERT(0 == uv_write2(&pc->write_req, + (uv_stream_t*) &pc->peer_handle, + &buf, + 1, + (uv_stream_t*) &sc->server_handle, + ipc_write_cb)); if (--sc->num_connects == 0) uv_close((uv_handle_t*) ipc_pipe, NULL); @@ -153,10 +153,10 @@ static void ipc_close_cb(uv_handle_t* handle) { static void ipc_connect_cb(uv_connect_t* req, int status) { struct ipc_client_ctx* ctx; ctx = container_of(req, struct ipc_client_ctx, connect_req); - ASSERT_OK(status); - ASSERT_OK(uv_read_start((uv_stream_t*) &ctx->ipc_pipe, - ipc_alloc_cb, - ipc_read_cb)); + ASSERT(0 == status); + ASSERT(0 == uv_read_start((uv_stream_t*) &ctx->ipc_pipe, + ipc_alloc_cb, + ipc_read_cb)); } @@ -182,16 +182,16 @@ static void ipc_read_cb(uv_stream_t* handle, ctx = container_of(ipc_pipe, struct ipc_client_ctx, ipc_pipe); loop = ipc_pipe->loop; - ASSERT_EQ(1, uv_pipe_pending_count(ipc_pipe)); + ASSERT(1 == uv_pipe_pending_count(ipc_pipe)); type = uv_pipe_pending_type(ipc_pipe); if (type == UV_TCP) - ASSERT_OK(uv_tcp_init(loop, (uv_tcp_t*) ctx->server_handle)); + ASSERT(0 == uv_tcp_init(loop, (uv_tcp_t*) ctx->server_handle)); else if (type == UV_NAMED_PIPE) - ASSERT_OK(uv_pipe_init(loop, (uv_pipe_t*) ctx->server_handle, 0)); + ASSERT(0 == uv_pipe_init(loop, (uv_pipe_t*) ctx->server_handle, 0)); else ASSERT(0); - ASSERT_OK(uv_accept(handle, ctx->server_handle)); + ASSERT(0 == uv_accept(handle, ctx->server_handle)); uv_close((uv_handle_t*) &ctx->ipc_pipe, NULL); } @@ -211,10 +211,10 @@ static void send_listen_handles(uv_handle_type type, ctx.num_connects = num_servers; if (type == UV_TCP) { - ASSERT_OK(uv_tcp_init(loop, (uv_tcp_t*) &ctx.server_handle)); - ASSERT_OK(uv_tcp_bind((uv_tcp_t*) &ctx.server_handle, - (const struct sockaddr*) &listen_addr, - 0)); + ASSERT(0 == uv_tcp_init(loop, (uv_tcp_t*) &ctx.server_handle)); + ASSERT(0 == uv_tcp_bind((uv_tcp_t*) &ctx.server_handle, + (const struct sockaddr*) &listen_addr, + 0)); } else ASSERT(0); @@ -223,16 +223,16 @@ static void send_listen_handles(uv_handle_type type, * If we accept a connection then the connected pipe must be initialized * with ipc=1. */ - ASSERT_OK(uv_pipe_init(loop, &ctx.ipc_pipe, 0)); - ASSERT_OK(uv_pipe_bind(&ctx.ipc_pipe, IPC_PIPE_NAME)); - ASSERT_OK(uv_listen((uv_stream_t*) &ctx.ipc_pipe, 128, ipc_connection_cb)); + ASSERT(0 == uv_pipe_init(loop, &ctx.ipc_pipe, 0)); + ASSERT(0 == uv_pipe_bind(&ctx.ipc_pipe, IPC_PIPE_NAME)); + ASSERT(0 == uv_listen((uv_stream_t*) &ctx.ipc_pipe, 128, ipc_connection_cb)); for (i = 0; i < num_servers; i++) uv_sem_post(&servers[i].semaphore); - ASSERT_OK(uv_run(loop, UV_RUN_DEFAULT)); + ASSERT(0 == uv_run(loop, UV_RUN_DEFAULT)); uv_close((uv_handle_t*) &ctx.server_handle, NULL); - ASSERT_OK(uv_run(loop, UV_RUN_DEFAULT)); + ASSERT(0 == uv_run(loop, UV_RUN_DEFAULT)); for (i = 0; i < num_servers; i++) uv_sem_wait(&servers[i].semaphore); @@ -245,12 +245,12 @@ static void get_listen_handle(uv_loop_t* loop, uv_stream_t* server_handle) { ctx.server_handle = server_handle; ctx.server_handle->data = "server handle"; - ASSERT_OK(uv_pipe_init(loop, &ctx.ipc_pipe, 1)); + ASSERT(0 == uv_pipe_init(loop, &ctx.ipc_pipe, 1)); uv_pipe_connect(&ctx.connect_req, &ctx.ipc_pipe, IPC_PIPE_NAME, ipc_connect_cb); - ASSERT_OK(uv_run(loop, UV_RUN_DEFAULT)); + ASSERT(0 == uv_run(loop, UV_RUN_DEFAULT)); } @@ -259,9 +259,9 @@ static void server_cb(void *arg) { uv_loop_t loop; ctx = arg; - ASSERT_OK(uv_loop_init(&loop)); + ASSERT(0 == uv_loop_init(&loop)); - ASSERT_OK(uv_async_init(&loop, &ctx->async_handle, sv_async_cb)); + ASSERT(0 == uv_async_init(&loop, &ctx->async_handle, sv_async_cb)); uv_unref((uv_handle_t*) &ctx->async_handle); /* Wait until the main thread is ready. */ @@ -270,10 +270,10 @@ static void server_cb(void *arg) { uv_sem_post(&ctx->semaphore); /* Now start the actual benchmark. */ - ASSERT_OK(uv_listen((uv_stream_t*) &ctx->server_handle, - 128, - sv_connection_cb)); - ASSERT_OK(uv_run(&loop, UV_RUN_DEFAULT)); + ASSERT(0 == uv_listen((uv_stream_t*) &ctx->server_handle, + 128, + sv_connection_cb)); + ASSERT(0 == uv_run(&loop, UV_RUN_DEFAULT)); uv_loop_close(&loop); } @@ -292,20 +292,20 @@ static void sv_connection_cb(uv_stream_t* server_handle, int status) { struct server_ctx* ctx; ctx = container_of(server_handle, struct server_ctx, server_handle); - ASSERT_OK(status); + ASSERT(status == 0); storage = malloc(sizeof(*storage)); ASSERT_NOT_NULL(storage); if (server_handle->type == UV_TCP) - ASSERT_OK(uv_tcp_init(server_handle->loop, (uv_tcp_t*) storage)); + ASSERT(0 == uv_tcp_init(server_handle->loop, (uv_tcp_t*) storage)); else if (server_handle->type == UV_NAMED_PIPE) - ASSERT_OK(uv_pipe_init(server_handle->loop, (uv_pipe_t*) storage, 0)); + ASSERT(0 == uv_pipe_init(server_handle->loop, (uv_pipe_t*) storage, 0)); else ASSERT(0); - ASSERT_OK(uv_accept(server_handle, (uv_stream_t*) storage)); - ASSERT_OK(uv_read_start((uv_stream_t*) storage, sv_alloc_cb, sv_read_cb)); + ASSERT(0 == uv_accept(server_handle, (uv_stream_t*) storage)); + ASSERT(0 == uv_read_start((uv_stream_t*) storage, sv_alloc_cb, sv_read_cb)); ctx->num_connects++; } @@ -322,7 +322,7 @@ static void sv_alloc_cb(uv_handle_t* handle, static void sv_read_cb(uv_stream_t* handle, ssize_t nread, const uv_buf_t* buf) { - ASSERT_EQ(nread, UV_EOF); + ASSERT(nread == UV_EOF); uv_close((uv_handle_t*) handle, (uv_close_cb) free); } @@ -330,7 +330,7 @@ static void sv_read_cb(uv_stream_t* handle, static void cl_connect_cb(uv_connect_t* req, int status) { struct client_ctx* ctx = container_of(req, struct client_ctx, connect_req); uv_idle_start(&ctx->idle_handle, cl_idle_cb); - ASSERT_OK(status); + ASSERT(0 == status); } @@ -351,11 +351,11 @@ static void cl_close_cb(uv_handle_t* handle) { return; } - ASSERT_OK(uv_tcp_init(handle->loop, (uv_tcp_t*) &ctx->client_handle)); - ASSERT_OK(uv_tcp_connect(&ctx->connect_req, - (uv_tcp_t*) &ctx->client_handle, - (const struct sockaddr*) &listen_addr, - cl_connect_cb)); + ASSERT(0 == uv_tcp_init(handle->loop, (uv_tcp_t*) &ctx->client_handle)); + ASSERT(0 == uv_tcp_connect(&ctx->connect_req, + (uv_tcp_t*) &ctx->client_handle, + (const struct sockaddr*) &listen_addr, + cl_connect_cb)); } @@ -367,7 +367,7 @@ static int test_tcp(unsigned int num_servers, unsigned int num_clients) { unsigned int i; double time; - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &listen_addr)); + ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &listen_addr)); loop = uv_default_loop(); servers = calloc(num_servers, sizeof(servers[0])); @@ -381,8 +381,8 @@ static int test_tcp(unsigned int num_servers, unsigned int num_clients) { */ for (i = 0; i < num_servers; i++) { struct server_ctx* ctx = servers + i; - ASSERT_OK(uv_sem_init(&ctx->semaphore, 0)); - ASSERT_OK(uv_thread_create(&ctx->thread_id, server_cb, ctx)); + ASSERT(0 == uv_sem_init(&ctx->semaphore, 0)); + ASSERT(0 == uv_thread_create(&ctx->thread_id, server_cb, ctx)); } send_listen_handles(UV_TCP, num_servers, servers); @@ -392,17 +392,17 @@ static int test_tcp(unsigned int num_servers, unsigned int num_clients) { ctx->num_connects = NUM_CONNECTS / num_clients; handle = (uv_tcp_t*) &ctx->client_handle; handle->data = "client handle"; - ASSERT_OK(uv_tcp_init(loop, handle)); - ASSERT_OK(uv_tcp_connect(&ctx->connect_req, - handle, - (const struct sockaddr*) &listen_addr, - cl_connect_cb)); - ASSERT_OK(uv_idle_init(loop, &ctx->idle_handle)); + ASSERT(0 == uv_tcp_init(loop, handle)); + ASSERT(0 == uv_tcp_connect(&ctx->connect_req, + handle, + (const struct sockaddr*) &listen_addr, + cl_connect_cb)); + ASSERT(0 == uv_idle_init(loop, &ctx->idle_handle)); } { uint64_t t = uv_hrtime(); - ASSERT_OK(uv_run(loop, UV_RUN_DEFAULT)); + ASSERT(0 == uv_run(loop, UV_RUN_DEFAULT)); t = uv_hrtime() - t; time = t / 1e9; } @@ -410,7 +410,7 @@ static int test_tcp(unsigned int num_servers, unsigned int num_clients) { for (i = 0; i < num_servers; i++) { struct server_ctx* ctx = servers + i; uv_async_send(&ctx->async_handle); - ASSERT_OK(uv_thread_join(&ctx->thread_id)); + ASSERT(0 == uv_thread_join(&ctx->thread_id)); uv_sem_destroy(&ctx->semaphore); } @@ -431,7 +431,7 @@ static int test_tcp(unsigned int num_servers, unsigned int num_clients) { free(clients); free(servers); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/benchmark-ping-pongs.c b/test/benchmark-ping-pongs.c index fd5f40b..646a7df 100644 --- a/test/benchmark-ping-pongs.c +++ b/test/benchmark-ping-pongs.c @@ -90,7 +90,7 @@ static void pinger_close_cb(uv_handle_t* handle) { static void pinger_write_cb(uv_write_t* req, int status) { - ASSERT_OK(status); + ASSERT(status == 0); free(req); } @@ -110,14 +110,14 @@ static void pinger_write_ping(pinger_t* pinger) { static void pinger_shutdown_cb(uv_shutdown_t* req, int status) { - ASSERT_OK(status); + ASSERT(status == 0); pinger_shutdown_cb_called++; /* * The close callback has not been triggered yet. We must wait for EOF * until we close the connection. */ - ASSERT_OK(completed_pingers); + ASSERT(completed_pingers == 0); } @@ -130,13 +130,13 @@ static void pinger_read_cb(uv_stream_t* tcp, pinger = (pinger_t*)tcp->data; if (nread < 0) { - ASSERT_EQ(nread, UV_EOF); + ASSERT(nread == UV_EOF); if (buf->base) { buf_free(buf); } - ASSERT_EQ(1, pinger_shutdown_cb_called); + ASSERT(pinger_shutdown_cb_called == 1); uv_close((uv_handle_t*)tcp, pinger_close_cb); return; @@ -144,7 +144,7 @@ static void pinger_read_cb(uv_stream_t* tcp, /* Now we count the pings */ for (i = 0; i < nread; i++) { - ASSERT_EQ(buf->base[i], PING[pinger->state]); + ASSERT(buf->base[i] == PING[pinger->state]); pinger->state = (pinger->state + 1) % (sizeof(PING) - 1); if (pinger->state == 0) { pinger->pongs++; @@ -166,7 +166,7 @@ static void pinger_read_cb(uv_stream_t* tcp, static void pinger_connect_cb(uv_connect_t* req, int status) { pinger_t *pinger = (pinger_t*)req->handle->data; - ASSERT_OK(status); + ASSERT(status == 0); pinger_write_ping(pinger); @@ -182,8 +182,8 @@ static void pinger_new(void) { pinger_t *pinger; int r; - ASSERT_OK(uv_ip4_addr("0.0.0.0", 0, &client_addr)); - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &server_addr)); + ASSERT(0 == uv_ip4_addr("0.0.0.0", 0, &client_addr)); + ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &server_addr)); pinger = malloc(sizeof(*pinger)); pinger->state = 0; pinger->pongs = 0; @@ -194,9 +194,9 @@ static void pinger_new(void) { pinger->tcp.data = pinger; - ASSERT_OK(uv_tcp_bind(&pinger->tcp, - (const struct sockaddr*) &client_addr, - 0)); + ASSERT(0 == uv_tcp_bind(&pinger->tcp, + (const struct sockaddr*) &client_addr, + 0)); r = uv_tcp_connect(&pinger->connect_req, &pinger->tcp, @@ -214,8 +214,8 @@ BENCHMARK_IMPL(ping_pongs) { pinger_new(); uv_run(loop, UV_RUN_DEFAULT); - ASSERT_EQ(1, completed_pingers); + ASSERT(completed_pingers == 1); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/benchmark-ping-udp.c b/test/benchmark-ping-udp.c index 2d2fe9c..cf9ca98 100644 --- a/test/benchmark-ping-udp.c +++ b/test/benchmark-ping-udp.c @@ -95,11 +95,11 @@ static void pinger_read_cb(uv_udp_t* udp, pinger = (pinger_t*)udp->data; /* No data here means something went wrong */ - ASSERT_GT(nread, 0); + ASSERT(nread > 0); /* Now we count the pings */ for (i = 0; i < nread; i++) { - ASSERT_EQ(buf->base[i], PING[pinger->state]); + ASSERT(buf->base[i] == PING[pinger->state]); pinger->state = (pinger->state + 1) % (sizeof(PING) - 1); if (pinger->state == 0) { pinger->pongs++; @@ -119,15 +119,15 @@ static void udp_pinger_new(void) { pinger_t* pinger = malloc(sizeof(*pinger)); int r; - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &pinger->server_addr)); + ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &pinger->server_addr)); pinger->state = 0; pinger->pongs = 0; /* Try to do NUM_PINGS ping-pongs (connection-less). */ r = uv_udp_init(loop, &pinger->udp); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_udp_bind(&pinger->udp, (const struct sockaddr*) &pinger->server_addr, 0); - ASSERT_OK(r); + ASSERT(r == 0); pinger->udp.data = pinger; @@ -148,12 +148,12 @@ static int ping_udp(unsigned pingers) { udp_pinger_new(); } uv_run(loop, UV_RUN_DEFAULT); - ASSERT_GE(completed_pingers, 1); + ASSERT(completed_pingers >= 1); fprintf(stderr, "ping_pongs: %d pingers, ~ %lu roundtrips/s\n", completed_pingers, completed_pings / (TIME/1000)); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/benchmark-pound.c b/test/benchmark-pound.c index 83ce522..830bc55 100644 --- a/test/benchmark-pound.c +++ b/test/benchmark-pound.c @@ -115,7 +115,7 @@ static void connect_cb(uv_connect_t* req, int status) { } ASSERT_NOT_NULL(req); - ASSERT_OK(status); + ASSERT(status == 0); conn = (conn_rec*)req->data; ASSERT_NOT_NULL(conn); @@ -125,13 +125,13 @@ static void connect_cb(uv_connect_t* req, int status) { #endif r = uv_read_start(&conn->stream, alloc_cb, read_cb); - ASSERT_OK(r); + ASSERT(r == 0); buf.base = buffer; buf.len = sizeof(buffer) - 1; r = uv_write(&conn->write_req, &conn->stream, &buf, 1, after_write); - ASSERT_OK(r); + ASSERT(r == 0); } @@ -200,9 +200,9 @@ static void tcp_make_connect(conn_rec* p) { tp = (tcp_conn_rec*) p; r = uv_tcp_init(loop, (uv_tcp_t*)&p->stream); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); + ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); r = uv_tcp_connect(&tp->conn_req, (uv_tcp_t*) &p->stream, @@ -227,7 +227,7 @@ static void pipe_make_connect(conn_rec* p) { int r; r = uv_pipe_init(loop, (uv_pipe_t*)&p->stream, 0); - ASSERT_OK(r); + ASSERT(r == 0); uv_pipe_connect(&((pipe_conn_rec*) p)->conn_req, (uv_pipe_t*) &p->stream, @@ -306,7 +306,7 @@ static int pound_it(int concurrency, conns_failed); fflush(stderr); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/benchmark-pump.c b/test/benchmark-pump.c index 8797668..7d3977d 100644 --- a/test/benchmark-pump.c +++ b/test/benchmark-pump.c @@ -159,9 +159,9 @@ static void start_stats_collection(void) { /* Show-stats timer */ stats_left = STATS_COUNT; r = uv_timer_init(loop, &timer_handle); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_timer_start(&timer_handle, show_stats, STATS_INTERVAL, STATS_INTERVAL); - ASSERT_OK(r); + ASSERT(r == 0); uv_update_time(loop); start_time = uv_now(loop); @@ -170,7 +170,7 @@ static void start_stats_collection(void) { static void read_cb(uv_stream_t* stream, ssize_t bytes, const uv_buf_t* buf) { if (nrecv_total == 0) { - ASSERT_OK(start_time); + ASSERT(start_time == 0); uv_update_time(loop); start_time = uv_now(loop); } @@ -188,7 +188,7 @@ static void read_cb(uv_stream_t* stream, ssize_t bytes, const uv_buf_t* buf) { static void write_cb(uv_write_t* req, int status) { - ASSERT_OK(status); + ASSERT(status == 0); req_free((uv_req_t*) req); @@ -209,7 +209,7 @@ static void do_write(uv_stream_t* stream) { req = (uv_write_t*) req_alloc(); r = uv_write(req, stream, &buf, 1, write_cb); - ASSERT_OK(r); + ASSERT(r == 0); } @@ -220,7 +220,7 @@ static void connect_cb(uv_connect_t* req, int status) { fprintf(stderr, "%s", uv_strerror(status)); fflush(stderr); } - ASSERT_OK(status); + ASSERT(status == 0); write_sockets++; req_free((uv_req_t*) req); @@ -253,19 +253,19 @@ static void maybe_connect_some(void) { tcp = &tcp_write_handles[max_connect_socket++]; r = uv_tcp_init(loop, tcp); - ASSERT_OK(r); + ASSERT(r == 0); req = (uv_connect_t*) req_alloc(); r = uv_tcp_connect(req, tcp, (const struct sockaddr*) &connect_addr, connect_cb); - ASSERT_OK(r); + ASSERT(r == 0); } else { pipe = &pipe_write_handles[max_connect_socket++]; r = uv_pipe_init(loop, pipe, 0); - ASSERT_OK(r); + ASSERT(r == 0); req = (uv_connect_t*) req_alloc(); uv_pipe_connect(req, pipe, TEST_PIPENAME, connect_cb); @@ -278,24 +278,24 @@ static void connection_cb(uv_stream_t* s, int status) { uv_stream_t* stream; int r; - ASSERT_PTR_EQ(server, s); - ASSERT_OK(status); + ASSERT(server == s); + ASSERT(status == 0); if (type == TCP) { stream = (uv_stream_t*)malloc(sizeof(uv_tcp_t)); r = uv_tcp_init(loop, (uv_tcp_t*)stream); - ASSERT_OK(r); + ASSERT(r == 0); } else { stream = (uv_stream_t*)malloc(sizeof(uv_pipe_t)); r = uv_pipe_init(loop, (uv_pipe_t*)stream, 0); - ASSERT_OK(r); + ASSERT(r == 0); } r = uv_accept(s, stream); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_read_start(stream, buf_alloc, read_cb); - ASSERT_OK(r); + ASSERT(r == 0); read_sockets++; max_read_sockets++; @@ -379,16 +379,16 @@ HELPER_IMPL(tcp_pump_server) { type = TCP; loop = uv_default_loop(); - ASSERT_OK(uv_ip4_addr("0.0.0.0", TEST_PORT, &listen_addr)); + ASSERT(0 == uv_ip4_addr("0.0.0.0", TEST_PORT, &listen_addr)); /* Server */ server = (uv_stream_t*)&tcpServer; r = uv_tcp_init(loop, &tcpServer); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_tcp_bind(&tcpServer, (const struct sockaddr*) &listen_addr, 0); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_listen((uv_stream_t*)&tcpServer, MAX_WRITE_HANDLES, connection_cb); - ASSERT_OK(r); + ASSERT(r == 0); notify_parent_process(); uv_run(loop, UV_RUN_DEFAULT); @@ -406,40 +406,40 @@ HELPER_IMPL(pipe_pump_server) { /* Server */ server = (uv_stream_t*)&pipeServer; r = uv_pipe_init(loop, &pipeServer, 0); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_pipe_bind(&pipeServer, TEST_PIPENAME); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_listen((uv_stream_t*)&pipeServer, MAX_WRITE_HANDLES, connection_cb); - ASSERT_OK(r); + ASSERT(r == 0); notify_parent_process(); uv_run(loop, UV_RUN_DEFAULT); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } static void tcp_pump(int n) { - ASSERT_LE(n, MAX_WRITE_HANDLES); + ASSERT(n <= MAX_WRITE_HANDLES); TARGET_CONNECTIONS = n; type = TCP; loop = uv_default_loop(); - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &connect_addr)); + ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &connect_addr)); /* Start making connections */ maybe_connect_some(); uv_run(loop, UV_RUN_DEFAULT); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); } static void pipe_pump(int n) { - ASSERT_LE(n, MAX_WRITE_HANDLES); + ASSERT(n <= MAX_WRITE_HANDLES); TARGET_CONNECTIONS = n; type = PIPE; @@ -450,7 +450,7 @@ static void pipe_pump(int n) { uv_run(loop, UV_RUN_DEFAULT); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); } diff --git a/test/benchmark-queue-work.c b/test/benchmark-queue-work.c index 5ae0883..2dd5cb6 100644 --- a/test/benchmark-queue-work.c +++ b/test/benchmark-queue-work.c @@ -40,13 +40,12 @@ static void work_cb(uv_work_t* req) { static void after_work_cb(uv_work_t* req, int status) { events++; if (!done) - ASSERT_OK(uv_queue_work(req->loop, req, work_cb, after_work_cb)); + ASSERT_EQ(0, uv_queue_work(req->loop, req, work_cb, after_work_cb)); } static void timer_cb(uv_timer_t* handle) { done = 1; } BENCHMARK_IMPL(queue_work) { - char fmtbuf[2][32]; uv_timer_t timer_handle; uv_work_t work; uv_loop_t* loop; @@ -55,17 +54,15 @@ BENCHMARK_IMPL(queue_work) { loop = uv_default_loop(); timeout = 5000; - ASSERT_OK(uv_timer_init(loop, &timer_handle)); - ASSERT_OK(uv_timer_start(&timer_handle, timer_cb, timeout, 0)); + ASSERT_EQ(0, uv_timer_init(loop, &timer_handle)); + ASSERT_EQ(0, uv_timer_start(&timer_handle, timer_cb, timeout, 0)); - ASSERT_OK(uv_queue_work(loop, &work, work_cb, after_work_cb)); - ASSERT_OK(uv_run(loop, UV_RUN_DEFAULT)); + ASSERT_EQ(0, uv_queue_work(loop, &work, work_cb, after_work_cb)); + ASSERT_EQ(0, uv_run(loop, UV_RUN_DEFAULT)); - printf("%s async jobs in %.1f seconds (%s/s)\n", - fmt(&fmtbuf[0], events), - timeout / 1000., - fmt(&fmtbuf[1], events / (timeout / 1000.))); + printf("%s async jobs in %.1f seconds (%s/s)\n", fmt(events), timeout / 1000., + fmt(events / (timeout / 1000.))); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/benchmark-spawn.c b/test/benchmark-spawn.c index ef27b38..ed9ad60 100644 --- a/test/benchmark-spawn.c +++ b/test/benchmark-spawn.c @@ -58,7 +58,7 @@ static void maybe_spawn(void) { static void process_close_cb(uv_handle_t* handle) { - ASSERT_EQ(1, process_open); + ASSERT(process_open == 1); process_open = 0; maybe_spawn(); } @@ -67,8 +67,8 @@ static void process_close_cb(uv_handle_t* handle) { static void exit_cb(uv_process_t* process, int64_t exit_status, int term_signal) { - ASSERT_EQ(42, exit_status); - ASSERT_OK(term_signal); + ASSERT(exit_status == 42); + ASSERT(term_signal == 0); uv_close((uv_handle_t*)process, process_close_cb); } @@ -82,7 +82,7 @@ static void on_alloc(uv_handle_t* handle, static void pipe_close_cb(uv_handle_t* pipe) { - ASSERT_EQ(1, pipe_open); + ASSERT(pipe_open == 1); pipe_open = 0; maybe_spawn(); } @@ -90,7 +90,7 @@ static void pipe_close_cb(uv_handle_t* pipe) { static void on_read(uv_stream_t* pipe, ssize_t nread, const uv_buf_t* buf) { if (nread > 0) { - ASSERT_EQ(1, pipe_open); + ASSERT(pipe_open == 1); output_used += nread; } else if (nread < 0) { if (nread == UV_EOF) { @@ -104,8 +104,8 @@ static void spawn(void) { uv_stdio_container_t stdio[2]; int r; - ASSERT_OK(process_open); - ASSERT_OK(pipe_open); + ASSERT(process_open == 0); + ASSERT(pipe_open == 0); args[0] = exepath; args[1] = "spawn_helper"; @@ -123,14 +123,14 @@ static void spawn(void) { options.stdio[1].data.stream = (uv_stream_t*)&out; r = uv_spawn(loop, &process, &options); - ASSERT_OK(r); + ASSERT(r == 0); process_open = 1; pipe_open = 1; output_used = 0; r = uv_read_start((uv_stream_t*) &out, on_alloc, on_read); - ASSERT_OK(r); + ASSERT(r == 0); } @@ -141,7 +141,7 @@ BENCHMARK_IMPL(spawn) { loop = uv_default_loop(); r = uv_exepath(exepath, &exepath_size); - ASSERT_OK(r); + ASSERT(r == 0); exepath[exepath_size] = '\0'; uv_update_time(loop); @@ -150,7 +150,7 @@ BENCHMARK_IMPL(spawn) { spawn(); r = uv_run(loop, UV_RUN_DEFAULT); - ASSERT_OK(r); + ASSERT(r == 0); uv_update_time(loop); end_time = uv_now(loop); @@ -159,6 +159,6 @@ BENCHMARK_IMPL(spawn) { (double) N / (double) (end_time - start_time) * 1000.0); fflush(stderr); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/benchmark-tcp-write-batch.c b/test/benchmark-tcp-write-batch.c index 9dfcf14..16aa72f 100644 --- a/test/benchmark-tcp-write-batch.c +++ b/test/benchmark-tcp-write-batch.c @@ -55,16 +55,16 @@ static void connect_cb(uv_connect_t* req, int status) { int i; int r; - ASSERT_PTR_EQ(req->handle, (uv_stream_t*)&tcp_client); + ASSERT(req->handle == (uv_stream_t*)&tcp_client); for (i = 0; i < NUM_WRITE_REQS; i++) { w = &write_reqs[i]; r = uv_write(&w->req, req->handle, &w->buf, 1, write_cb); - ASSERT_OK(r); + ASSERT(r == 0); } r = uv_shutdown(&shutdown_req, req->handle, shutdown_cb); - ASSERT_OK(r); + ASSERT(r == 0); connect_cb_called++; } @@ -72,14 +72,14 @@ static void connect_cb(uv_connect_t* req, int status) { static void write_cb(uv_write_t* req, int status) { ASSERT_NOT_NULL(req); - ASSERT_OK(status); + ASSERT(status == 0); write_cb_called++; } static void shutdown_cb(uv_shutdown_t* req, int status) { - ASSERT_PTR_EQ(req->handle, (uv_stream_t*)&tcp_client); - ASSERT_OK(req->handle->write_queue_size); + ASSERT(req->handle == (uv_stream_t*)&tcp_client); + ASSERT(req->handle->write_queue_size == 0); uv_close((uv_handle_t*)req->handle, close_cb); free(write_reqs); @@ -89,7 +89,7 @@ static void shutdown_cb(uv_shutdown_t* req, int status) { static void close_cb(uv_handle_t* handle) { - ASSERT_PTR_EQ(handle, (uv_handle_t*)&tcp_client); + ASSERT(handle == (uv_handle_t*)&tcp_client); close_cb_called++; } @@ -112,33 +112,33 @@ BENCHMARK_IMPL(tcp_write_batch) { } loop = uv_default_loop(); - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); + ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); r = uv_tcp_init(loop, &tcp_client); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_tcp_connect(&connect_req, &tcp_client, (const struct sockaddr*) &addr, connect_cb); - ASSERT_OK(r); + ASSERT(r == 0); start = uv_hrtime(); r = uv_run(loop, UV_RUN_DEFAULT); - ASSERT_OK(r); + ASSERT(r == 0); stop = uv_hrtime(); - ASSERT_EQ(1, connect_cb_called); - ASSERT_EQ(write_cb_called, NUM_WRITE_REQS); - ASSERT_EQ(1, shutdown_cb_called); - ASSERT_EQ(1, close_cb_called); + ASSERT(connect_cb_called == 1); + ASSERT(write_cb_called == NUM_WRITE_REQS); + ASSERT(shutdown_cb_called == 1); + ASSERT(close_cb_called == 1); printf("%ld write requests in %.2fs.\n", (long)NUM_WRITE_REQS, (stop - start) / 1e9); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/benchmark-thread.c b/test/benchmark-thread.c index b339e7c..b37a7fd 100644 --- a/test/benchmark-thread.c +++ b/test/benchmark-thread.c @@ -31,7 +31,7 @@ static volatile int num_threads; static void thread_entry(void* arg) { - ASSERT_PTR_EQ(arg, (void *) 42); + ASSERT(arg == (void *) 42); num_threads++; /* FIXME write barrier? */ } @@ -47,15 +47,15 @@ BENCHMARK_IMPL(thread_create) { for (i = 0; i < NUM_THREADS; i++) { r = uv_thread_create(&tid, thread_entry, (void *) 42); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_thread_join(&tid); - ASSERT_OK(r); + ASSERT(r == 0); } duration = (uv_hrtime() - start_time) / 1e9; - ASSERT_EQ(num_threads, NUM_THREADS); + ASSERT(num_threads == NUM_THREADS); printf("%d threads created in %.2f seconds (%.0f/s)\n", NUM_THREADS, duration, NUM_THREADS / duration); diff --git a/test/benchmark-udp-pummel.c b/test/benchmark-udp-pummel.c index 7b7e1af..1a22057 100644 --- a/test/benchmark-udp-pummel.c +++ b/test/benchmark-udp-pummel.c @@ -63,7 +63,7 @@ static void alloc_cb(uv_handle_t* handle, size_t suggested_size, uv_buf_t* buf) { static char slab[65536]; - ASSERT_LE(suggested_size, sizeof(slab)); + ASSERT(suggested_size <= sizeof(slab)); buf->base = slab; buf->len = sizeof(slab); } @@ -75,7 +75,7 @@ static void send_cb(uv_udp_send_t* req, int status) { ASSERT_NOT_NULL(req); if (status != 0) { - ASSERT_EQ(status, UV_ECANCELED); + ASSERT(status == UV_ECANCELED); return; } @@ -83,7 +83,7 @@ static void send_cb(uv_udp_send_t* req, int status) { return; s = container_of(req, struct sender_state, send_req); - ASSERT_PTR_EQ(req->handle, &s->udp_handle); + ASSERT(req->handle == &s->udp_handle); if (timed) goto send; @@ -96,12 +96,12 @@ static void send_cb(uv_udp_send_t* req, int status) { packet_counter--; send: - ASSERT_OK(uv_udp_send(&s->send_req, - &s->udp_handle, - bufs, - ARRAY_SIZE(bufs), - (const struct sockaddr*) &s->addr, - send_cb)); + ASSERT(0 == uv_udp_send(&s->send_req, + &s->udp_handle, + bufs, + ARRAY_SIZE(bufs), + (const struct sockaddr*) &s->addr, + send_cb)); send_cb_called++; } @@ -115,11 +115,11 @@ static void recv_cb(uv_udp_t* handle, return; if (nread < 0) { - ASSERT_EQ(nread, UV_ECANCELED); + ASSERT(nread == UV_ECANCELED); return; } - ASSERT_EQ(addr->sa_family, AF_INET); + ASSERT(addr->sa_family == AF_INET); ASSERT(!memcmp(buf->base, EXPECTED, nread)); recv_cb_called++; @@ -153,8 +153,8 @@ static int pummel(unsigned int n_senders, uv_loop_t* loop; unsigned int i; - ASSERT_LE(n_senders, ARRAY_SIZE(senders)); - ASSERT_LE(n_receivers, ARRAY_SIZE(receivers)); + ASSERT(n_senders <= ARRAY_SIZE(senders)); + ASSERT(n_receivers <= ARRAY_SIZE(receivers)); loop = uv_default_loop(); @@ -162,8 +162,8 @@ static int pummel(unsigned int n_senders, n_receivers_ = n_receivers; if (timeout) { - ASSERT_OK(uv_timer_init(loop, &timer_handle)); - ASSERT_OK(uv_timer_start(&timer_handle, timeout_cb, timeout, 0)); + ASSERT(0 == uv_timer_init(loop, &timer_handle)); + ASSERT(0 == uv_timer_start(&timer_handle, timeout_cb, timeout, 0)); /* Timer should not keep loop alive. */ uv_unref((uv_handle_t*)&timer_handle); timed = 1; @@ -172,10 +172,10 @@ static int pummel(unsigned int n_senders, for (i = 0; i < n_receivers; i++) { struct receiver_state* s = receivers + i; struct sockaddr_in addr; - ASSERT_OK(uv_ip4_addr("0.0.0.0", BASE_PORT + i, &addr)); - ASSERT_OK(uv_udp_init(loop, &s->udp_handle)); - ASSERT_OK(uv_udp_bind(&s->udp_handle, (const struct sockaddr*) &addr, 0)); - ASSERT_OK(uv_udp_recv_start(&s->udp_handle, alloc_cb, recv_cb)); + ASSERT(0 == uv_ip4_addr("0.0.0.0", BASE_PORT + i, &addr)); + ASSERT(0 == uv_udp_init(loop, &s->udp_handle)); + ASSERT(0 == uv_udp_bind(&s->udp_handle, (const struct sockaddr*) &addr, 0)); + ASSERT(0 == uv_udp_recv_start(&s->udp_handle, alloc_cb, recv_cb)); uv_unref((uv_handle_t*)&s->udp_handle); } @@ -187,20 +187,20 @@ static int pummel(unsigned int n_senders, for (i = 0; i < n_senders; i++) { struct sender_state* s = senders + i; - ASSERT_OK(uv_ip4_addr("127.0.0.1", - BASE_PORT + (i % n_receivers), - &s->addr)); - ASSERT_OK(uv_udp_init(loop, &s->udp_handle)); - ASSERT_OK(uv_udp_send(&s->send_req, - &s->udp_handle, - bufs, - ARRAY_SIZE(bufs), - (const struct sockaddr*) &s->addr, - send_cb)); + ASSERT(0 == uv_ip4_addr("127.0.0.1", + BASE_PORT + (i % n_receivers), + &s->addr)); + ASSERT(0 == uv_udp_init(loop, &s->udp_handle)); + ASSERT(0 == uv_udp_send(&s->send_req, + &s->udp_handle, + bufs, + ARRAY_SIZE(bufs), + (const struct sockaddr*) &s->addr, + send_cb)); } duration = uv_hrtime(); - ASSERT_OK(uv_run(loop, UV_RUN_DEFAULT)); + ASSERT(0 == uv_run(loop, UV_RUN_DEFAULT)); duration = uv_hrtime() - duration; /* convert from nanoseconds to milliseconds */ duration = duration / (uint64_t) 1e6; @@ -215,7 +215,7 @@ static int pummel(unsigned int n_senders, send_cb_called, duration / 1000.0); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/blackhole-server.c b/test/blackhole-server.c index 79d6146..0a8758e 100644 --- a/test/blackhole-server.c +++ b/test/blackhole-server.c @@ -43,20 +43,20 @@ static void connection_cb(uv_stream_t* stream, int status) { conn_rec* conn; int r; - ASSERT_OK(status); - ASSERT_PTR_EQ(stream, (uv_stream_t*)&tcp_server); + ASSERT(status == 0); + ASSERT(stream == (uv_stream_t*)&tcp_server); conn = malloc(sizeof *conn); ASSERT_NOT_NULL(conn); r = uv_tcp_init(stream->loop, &conn->handle); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_accept(stream, (uv_stream_t*)&conn->handle); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_read_start((uv_stream_t*)&conn->handle, alloc_cb, read_cb); - ASSERT_OK(r); + ASSERT(r == 0); } @@ -76,12 +76,12 @@ static void read_cb(uv_stream_t* stream, ssize_t nread, const uv_buf_t* buf) { if (nread >= 0) return; - ASSERT_EQ(nread, UV_EOF); + ASSERT(nread == UV_EOF); conn = container_of(stream, conn_rec, handle); r = uv_shutdown(&conn->shutdown_req, stream, shutdown_cb); - ASSERT_OK(r); + ASSERT(r == 0); } @@ -103,16 +103,16 @@ HELPER_IMPL(tcp4_blackhole_server) { int r; loop = uv_default_loop(); - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); + ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); r = uv_tcp_init(loop, &tcp_server); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_tcp_bind(&tcp_server, (const struct sockaddr*) &addr, 0); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_listen((uv_stream_t*)&tcp_server, 128, connection_cb); - ASSERT_OK(r); + ASSERT(r == 0); notify_parent_process(); r = uv_run(loop, UV_RUN_DEFAULT); diff --git a/test/echo-server.c b/test/echo-server.c index 572f87d..0f6fc54 100644 --- a/test/echo-server.c +++ b/test/echo-server.c @@ -65,14 +65,12 @@ static void after_write(uv_write_t* req, int status) { static void after_shutdown(uv_shutdown_t* req, int status) { - ASSERT_OK(status); uv_close((uv_handle_t*) req->handle, on_close); free(req); } static void on_shutdown(uv_shutdown_t* req, int status) { - ASSERT_OK(status); free(req); } @@ -92,7 +90,7 @@ static void after_read(uv_stream_t* handle, free(buf->base); sreq = malloc(sizeof* sreq); if (uv_is_writable(handle)) { - ASSERT_OK(uv_shutdown(sreq, handle, after_shutdown)); + ASSERT_EQ(0, uv_shutdown(sreq, handle, after_shutdown)); } return; } @@ -118,7 +116,7 @@ static void after_read(uv_stream_t* handle, if (i + 2 < nread && buf->base[i + 2] == 'H') reset = 1; if (reset && handle->type == UV_TCP) - ASSERT_OK(uv_tcp_close_reset((uv_tcp_t*) handle, on_close)); + ASSERT_EQ(0, uv_tcp_close_reset((uv_tcp_t*) handle, on_close)); else if (shutdown) break; else @@ -141,7 +139,7 @@ static void after_read(uv_stream_t* handle, } if (shutdown) - ASSERT_OK(uv_shutdown(malloc(sizeof* sreq), handle, on_shutdown)); + ASSERT_EQ(0, uv_shutdown(malloc(sizeof* sreq), handle, on_shutdown)); } @@ -173,21 +171,21 @@ static void on_connection(uv_stream_t* server, int status) { if (status != 0) { fprintf(stderr, "Connect error %s\n", uv_err_name(status)); } - ASSERT_OK(status); + ASSERT(status == 0); switch (serverType) { case TCP: stream = malloc(sizeof(uv_tcp_t)); ASSERT_NOT_NULL(stream); r = uv_tcp_init(loop, (uv_tcp_t*)stream); - ASSERT_OK(r); + ASSERT(r == 0); break; case PIPE: stream = malloc(sizeof(uv_pipe_t)); ASSERT_NOT_NULL(stream); r = uv_pipe_init(loop, (uv_pipe_t*)stream, 0); - ASSERT_OK(r); + ASSERT(r == 0); break; default: @@ -199,15 +197,15 @@ static void on_connection(uv_stream_t* server, int status) { stream->data = server; r = uv_accept(server, stream); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_read_start(stream, echo_alloc, after_read); - ASSERT_OK(r); + ASSERT(r == 0); } static void on_server_close(uv_handle_t* handle) { - ASSERT_PTR_EQ(handle, server); + ASSERT(handle == server); } static uv_udp_send_t* send_alloc(void) { @@ -221,7 +219,7 @@ static uv_udp_send_t* send_alloc(void) { static void on_send(uv_udp_send_t* req, int status) { ASSERT_NOT_NULL(req); - ASSERT_OK(status); + ASSERT(status == 0); req->data = send_freelist; send_freelist = req; } @@ -239,20 +237,20 @@ static void on_recv(uv_udp_t* handle, return; } - ASSERT_GT(nread, 0); - ASSERT_EQ(addr->sa_family, AF_INET); + ASSERT(nread > 0); + ASSERT(addr->sa_family == AF_INET); req = send_alloc(); ASSERT_NOT_NULL(req); sndbuf = uv_buf_init(rcvbuf->base, nread); - ASSERT_LE(0, uv_udp_send(req, handle, &sndbuf, 1, addr, on_send)); + ASSERT(0 <= uv_udp_send(req, handle, &sndbuf, 1, addr, on_send)); } static int tcp4_echo_start(int port) { struct sockaddr_in addr; int r; - ASSERT_OK(uv_ip4_addr("127.0.0.1", port, &addr)); + ASSERT(0 == uv_ip4_addr("127.0.0.1", port, &addr)); server = (uv_handle_t*)&tcpServer; serverType = TCP; @@ -286,7 +284,7 @@ static int tcp6_echo_start(int port) { struct sockaddr_in6 addr6; int r; - ASSERT_OK(uv_ip6_addr("::1", port, &addr6)); + ASSERT(0 == uv_ip6_addr("::1", port, &addr6)); server = (uv_handle_t*)&tcpServer; serverType = TCP; @@ -321,7 +319,7 @@ static int udp4_echo_start(int port) { struct sockaddr_in addr; int r; - ASSERT_OK(uv_ip4_addr("127.0.0.1", port, &addr)); + ASSERT(0 == uv_ip4_addr("127.0.0.1", port, &addr)); server = (uv_handle_t*)&udpServer; serverType = UDP; diff --git a/test/fixtures/one_file/one_file b/test/fixtures/one_file/one_file deleted file mode 100644 index e69de29..0000000 diff --git a/test/run-tests.c b/test/run-tests.c index 17fb0e0..467f2d5 100644 --- a/test/run-tests.c +++ b/test/run-tests.c @@ -25,7 +25,6 @@ #ifdef _WIN32 # include -# define read _read #else # include #endif @@ -66,13 +65,6 @@ typedef BOOL (WINAPI *sCompareObjectHandles)(_In_ HANDLE, _In_ HANDLE); int main(int argc, char **argv) { -#ifndef _WIN32 - if (0 == geteuid() && NULL == getenv("UV_RUN_AS_ROOT")) { - fprintf(stderr, "The libuv test suite cannot be run as root.\n"); - return EXIT_FAILURE; - } -#endif - platform_init(argc, argv); argv = uv_setup_args(argc, argv); @@ -86,6 +78,10 @@ int main(int argc, char **argv) { fflush(stderr); return EXIT_FAILURE; } + +#ifndef __SUNPRO_C + return EXIT_SUCCESS; +#endif } @@ -146,7 +142,7 @@ static int maybe_run_test(int argc, char **argv) { if (strcmp(argv[1], "spawn_helper3") == 0) { char buffer[256]; notify_parent_process(); - ASSERT_PTR_EQ(buffer, fgets(buffer, sizeof(buffer) - 1, stdin)); + ASSERT(buffer == fgets(buffer, sizeof(buffer) - 1, stdin)); buffer[sizeof(buffer) - 1] = '\0'; fputs(buffer, stdout); return 1; @@ -184,10 +180,10 @@ static int maybe_run_test(int argc, char **argv) { notify_parent_process(); r = fprintf(stdout, "hello world\n"); - ASSERT_GT(r, 0); + ASSERT(r > 0); r = fprintf(stderr, "hello errworld\n"); - ASSERT_GT(r, 0); + ASSERT(r > 0); return 1; } @@ -203,7 +199,7 @@ static int maybe_run_test(int argc, char **argv) { ASSERT_NOT_NULL(test); r = fprintf(stdout, "%s", test); - ASSERT_GT(r, 0); + ASSERT(r > 0); return 1; } @@ -217,24 +213,23 @@ static int maybe_run_test(int argc, char **argv) { sCompareObjectHandles pCompareObjectHandles; /* function introduced in Windows 10 */ #endif notify_parent_process(); - ASSERT_EQ(sizeof(closed_fd), read(0, &closed_fd, sizeof(closed_fd))); - ASSERT_EQ(sizeof(open_fd), read(0, &open_fd, sizeof(open_fd))); + ASSERT(sizeof(closed_fd) == read(0, &closed_fd, sizeof(closed_fd))); + ASSERT(sizeof(open_fd) == read(0, &open_fd, sizeof(open_fd))); #ifdef _WIN32 - ASSERT_GT((intptr_t) closed_fd, 0); - ASSERT_GT((intptr_t) open_fd, 0); - ASSERT_NE(0, GetHandleInformation(open_fd, &flags)); + ASSERT((intptr_t) closed_fd > 0); + ASSERT((intptr_t) open_fd > 0); + ASSERT(0 != GetHandleInformation(open_fd, &flags)); kernelbase_module = GetModuleHandleA("kernelbase.dll"); pCompareObjectHandles = (sCompareObjectHandles) GetProcAddress(kernelbase_module, "CompareObjectHandles"); - ASSERT_NE(pCompareObjectHandles == NULL || \ - !pCompareObjectHandles(open_fd, closed_fd), 0); + ASSERT(pCompareObjectHandles == NULL || !pCompareObjectHandles(open_fd, closed_fd)); #else - ASSERT_GT(open_fd, 2); - ASSERT_GT(closed_fd, 2); + ASSERT(open_fd > 2); + ASSERT(closed_fd > 2); # if defined(__PASE__) /* On IBMi PASE, write() returns 1 */ - ASSERT_EQ(1, write(closed_fd, "x", 1)); + ASSERT(1 == write(closed_fd, "x", 1)); # else - ASSERT_EQ(-1, write(closed_fd, "x", 1)); + ASSERT(-1 == write(closed_fd, "x", 1)); # endif /* !__PASE__ */ #endif return 1; @@ -251,8 +246,8 @@ static int maybe_run_test(int argc, char **argv) { uv_uid_t uid = atoi(argv[2]); uv_gid_t gid = atoi(argv[3]); - ASSERT_EQ(uid, getuid()); - ASSERT_EQ(gid, getgid()); + ASSERT(uid == getuid()); + ASSERT(gid == getgid()); notify_parent_process(); return 1; diff --git a/test/runner-unix.c b/test/runner-unix.c index 81560ad..bd4a749 100644 --- a/test/runner-unix.c +++ b/test/runner-unix.c @@ -40,10 +40,6 @@ #include #include -#ifdef __APPLE__ -#include -#endif - extern char** environ; static void closefd(int fd) { @@ -112,7 +108,7 @@ int process_start(char* name, char* part, process_info_t* p, int is_helper) { args[n++] = part; args[n++] = NULL; - stdout_file = tmpfile(); + stdout_file = fopen("/data/local/tmp/test.txt", "w+"); stdout_fd = fileno(stdout_file); if (!stdout_file) { perror("tmpfile"); @@ -135,11 +131,7 @@ int process_start(char* name, char* part, process_info_t* p, int is_helper) { p->terminated = 0; p->status = 0; -#if defined(__APPLE__) && (TARGET_OS_TV || TARGET_OS_WATCH) - pid = -1; -#else pid = fork(); -#endif if (pid < 0) { perror("fork"); @@ -150,11 +142,7 @@ int process_start(char* name, char* part, process_info_t* p, int is_helper) { /* child */ if (is_helper) closefd(pipefd[0]); - dup2(stdout_fd, STDOUT_FILENO); - dup2(stdout_fd, STDERR_FILENO); -#if !(defined(__APPLE__) && (TARGET_OS_TV || TARGET_OS_WATCH)) execve(args[0], args, environ); -#endif perror("execve()"); _exit(127); } @@ -354,7 +342,6 @@ long int process_output_size(process_info_t *p) { /* Size of the p->stdout_file */ struct stat buf; - memset(&buf, 0, sizeof(buf)); int r = fstat(fileno(p->stdout_file), &buf); if (r < 0) { return -1; diff --git a/test/runner-win.c b/test/runner-win.c index 6c6e35f..8c2a00b 100644 --- a/test/runner-win.c +++ b/test/runner-win.c @@ -185,7 +185,7 @@ int process_wait(process_info_t *vec, int n, int timeout) { if (n == 0) return 0; - ASSERT_LE(n, MAXIMUM_WAIT_OBJECTS); + ASSERT(n <= MAXIMUM_WAIT_OBJECTS); for (i = 0; i < n; i++) handles[i] = vec[i].process; @@ -245,7 +245,7 @@ int process_read_last_line(process_info_t *p, DWORD start; OVERLAPPED overlapped; - ASSERT_GT(buffer_len, 0); + ASSERT(buffer_len > 0); size = GetFileSize(p->stdio_out, NULL); if (size == INVALID_FILE_SIZE) @@ -310,7 +310,7 @@ static int clear_line(void) { COORD coord; DWORD written; - handle = (HANDLE)_get_osfhandle(_fileno(stderr)); + handle = (HANDLE)_get_osfhandle(fileno(stderr)); if (handle == INVALID_HANDLE_VALUE) return -1; diff --git a/test/runner.c b/test/runner.c index d1dd02f..7891082 100644 --- a/test/runner.c +++ b/test/runner.c @@ -37,14 +37,28 @@ static int compare_task(const void* va, const void* vb) { } -char* fmt(char (*buf)[32], double d) { +const char* fmt(double d) { + static char buf[1024]; + static char* p; uint64_t v; - char* p; - p = &(*buf)[32]; + if (p == NULL) + p = buf; + + p += 31; + + if (p >= buf + sizeof(buf)) + return ""; + v = (uint64_t) d; - *--p = '\0'; +#if 0 /* works but we don't care about fractional precision */ + if (d - v >= 0.01) { + *--p = '0' + (uint64_t) (d * 100) % 10; + *--p = '0' + (uint64_t) (d * 10) % 10; + *--p = '.'; + } +#endif if (v == 0) *--p = '0'; @@ -63,7 +77,9 @@ char* fmt(char (*buf)[32], double d) { int run_tests(int benchmark_output) { int actual; int total; + int passed; int failed; + int skipped; int current; int test_result; int skip; @@ -86,7 +102,9 @@ int run_tests(int benchmark_output) { fflush(stdout); /* Run all tests. */ + passed = 0; failed = 0; + skipped = 0; current = 1; for (task = TASKS; task->main; task++) { if (task->is_helper) { @@ -95,8 +113,8 @@ int run_tests(int benchmark_output) { test_result = run_test(task->task_name, benchmark_output, current); switch (test_result) { - case TEST_OK: break; - case TEST_SKIP: break; + case TEST_OK: passed++; break; + case TEST_SKIP: skipped++; break; default: failed++; } current++; diff --git a/test/task.h b/test/task.h index 8b83532..925f1b1 100644 --- a/test/task.h +++ b/test/task.h @@ -29,7 +29,12 @@ #include #include #include -#include + +#if defined(_MSC_VER) && _MSC_VER < 1600 +# include "uv/stdint-msvc2008.h" +#else +# include +#endif #if !defined(_WIN32) # include @@ -50,9 +55,9 @@ #define TEST_PORT_3 9125 #ifdef _WIN32 -# define TEST_PIPENAME "\\\\.\\pipe\\uv-test" -# define TEST_PIPENAME_2 "\\\\.\\pipe\\uv-test2" -# define TEST_PIPENAME_3 "\\\\.\\pipe\\uv-test3" +# define TEST_PIPENAME "\\\\?\\pipe\\uv-test" +# define TEST_PIPENAME_2 "\\\\?\\pipe\\uv-test2" +# define TEST_PIPENAME_3 "\\\\?\\pipe\\uv-test3" #else # define TEST_PIPENAME "/tmp/uv-test-sock" # define TEST_PIPENAME_2 "/tmp/uv-test-sock2" @@ -198,7 +203,6 @@ typedef enum { #define ASSERT_LE(a, b) ASSERT_BASE(a, <=, b, int64_t, PRId64) #define ASSERT_LT(a, b) ASSERT_BASE(a, <, b, int64_t, PRId64) #define ASSERT_NE(a, b) ASSERT_BASE(a, !=, b, int64_t, PRId64) -#define ASSERT_OK(a) ASSERT_BASE(a, ==, 0, int64_t, PRId64) #define ASSERT_UINT64_EQ(a, b) ASSERT_BASE(a, ==, b, uint64_t, PRIu64) #define ASSERT_UINT64_GE(a, b) ASSERT_BASE(a, >=, b, uint64_t, PRIu64) @@ -244,16 +248,13 @@ typedef enum { #define ASSERT_PTR_NE(a, b) \ ASSERT_BASE(a, !=, b, void*, "p") -#define ASSERT_PTR_LT(a, b) \ - ASSERT_BASE(a, <, b, void*, "p") - -/* This macro cleans up the event loop. This is used to avoid valgrind - * warnings about memory being "leaked" by the event loop. +/* This macro cleans up the main loop. This is used to avoid valgrind + * warnings about memory being "leaked" by the main event loop. */ -#define MAKE_VALGRIND_HAPPY(loop) \ +#define MAKE_VALGRIND_HAPPY() \ do { \ - close_loop(loop); \ - ASSERT_EQ(0, uv_loop_close(loop)); \ + close_loop(uv_default_loop()); \ + ASSERT(0 == uv_loop_close(uv_default_loop())); \ uv_library_shutdown(); \ } while (0) @@ -270,8 +271,8 @@ typedef enum { int run_helper_##name(void); \ int run_helper_##name(void) -/* Format big numbers nicely. */ -char* fmt(char (*buf)[32], double d); +/* Format big numbers nicely. WARNING: leaks memory. */ +const char* fmt(double d); /* Reserved test exit codes. */ enum test_status { @@ -374,11 +375,4 @@ UNUSED static int can_ipv6(void) { "Cygwin runtime hangs on listen+connect in same process." #endif -#if !defined(__linux__) && \ - !(defined(__FreeBSD__) && __FreeBSD_version >= 1301000) && \ - !defined(_WIN32) -# define NO_CPU_AFFINITY \ - "affinity not supported on this platform." -#endif - #endif /* TASK_H_ */ diff --git a/test/test-active.c b/test/test-active.c index fadbd10..3843895 100644 --- a/test/test-active.c +++ b/test/test-active.c @@ -45,40 +45,40 @@ TEST_IMPL(active) { uv_timer_t timer; r = uv_timer_init(uv_default_loop(), &timer); - ASSERT_OK(r); + ASSERT(r == 0); /* uv_is_active() and uv_is_closing() should always return either 0 or 1. */ - ASSERT_OK(uv_is_active((uv_handle_t*) &timer)); - ASSERT_OK(uv_is_closing((uv_handle_t*) &timer)); + ASSERT(0 == uv_is_active((uv_handle_t*) &timer)); + ASSERT(0 == uv_is_closing((uv_handle_t*) &timer)); r = uv_timer_start(&timer, timer_cb, 1000, 0); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_EQ(1, uv_is_active((uv_handle_t*) &timer)); - ASSERT_OK(uv_is_closing((uv_handle_t*) &timer)); + ASSERT(1 == uv_is_active((uv_handle_t*) &timer)); + ASSERT(0 == uv_is_closing((uv_handle_t*) &timer)); r = uv_timer_stop(&timer); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_OK(uv_is_active((uv_handle_t*) &timer)); - ASSERT_OK(uv_is_closing((uv_handle_t*) &timer)); + ASSERT(0 == uv_is_active((uv_handle_t*) &timer)); + ASSERT(0 == uv_is_closing((uv_handle_t*) &timer)); r = uv_timer_start(&timer, timer_cb, 1000, 0); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_EQ(1, uv_is_active((uv_handle_t*) &timer)); - ASSERT_OK(uv_is_closing((uv_handle_t*) &timer)); + ASSERT(1 == uv_is_active((uv_handle_t*) &timer)); + ASSERT(0 == uv_is_closing((uv_handle_t*) &timer)); uv_close((uv_handle_t*) &timer, close_cb); - ASSERT_OK(uv_is_active((uv_handle_t*) &timer)); - ASSERT_EQ(1, uv_is_closing((uv_handle_t*) &timer)); + ASSERT(0 == uv_is_active((uv_handle_t*) &timer)); + ASSERT(1 == uv_is_closing((uv_handle_t*) &timer)); r = uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_EQ(1, close_cb_called); + ASSERT(close_cb_called == 1); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-async-null-cb.c b/test/test-async-null-cb.c index ac9fc89..52652d9 100644 --- a/test/test-async-null-cb.c +++ b/test/test-async-null-cb.c @@ -36,7 +36,7 @@ static void thread_cb(void* dummy) { static void check_cb(uv_check_t* handle) { - ASSERT_OK(check_cb_called); + ASSERT(check_cb_called == 0); uv_close((uv_handle_t*) &async_handle, NULL); uv_close((uv_handle_t*) &check_handle, NULL); check_cb_called++; @@ -52,13 +52,13 @@ TEST_IMPL(async_null_cb) { */ memset(&async_handle, 0xff, sizeof(async_handle)); - ASSERT_OK(uv_async_init(uv_default_loop(), &async_handle, NULL)); - ASSERT_OK(uv_check_init(uv_default_loop(), &check_handle)); - ASSERT_OK(uv_check_start(&check_handle, check_cb)); - ASSERT_OK(uv_thread_create(&thread, thread_cb, NULL)); - ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT)); - ASSERT_OK(uv_thread_join(&thread)); - ASSERT_EQ(1, check_cb_called); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + ASSERT(0 == uv_async_init(uv_default_loop(), &async_handle, NULL)); + ASSERT(0 == uv_check_init(uv_default_loop(), &check_handle)); + ASSERT(0 == uv_check_start(&check_handle, check_cb)); + ASSERT(0 == uv_thread_create(&thread, thread_cb, NULL)); + ASSERT(0 == uv_run(uv_default_loop(), UV_RUN_DEFAULT)); + ASSERT(0 == uv_thread_join(&thread)); + ASSERT(1 == check_cb_called); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-async.c b/test/test-async.c index 935436e..619be62 100644 --- a/test/test-async.c +++ b/test/test-async.c @@ -49,7 +49,7 @@ static void thread_cb(void *arg) { } r = uv_async_send(&async); - ASSERT_OK(r); + ASSERT(r == 0); /* Work around a bug in Valgrind. * @@ -78,7 +78,7 @@ static void close_cb(uv_handle_t* handle) { static void async_cb(uv_async_t* handle) { int n; - ASSERT_PTR_EQ(handle, &async); + ASSERT(handle == &async); uv_mutex_lock(&mutex); n = ++async_cb_called; @@ -94,13 +94,13 @@ static void async_cb(uv_async_t* handle) { static void prepare_cb(uv_prepare_t* handle) { int r; - ASSERT_PTR_EQ(handle, &prepare); + ASSERT(handle == &prepare); if (prepare_cb_called++) return; r = uv_thread_create(&thread, thread_cb, NULL); - ASSERT_OK(r); + ASSERT(r == 0); uv_mutex_unlock(&mutex); } @@ -109,26 +109,26 @@ TEST_IMPL(async) { int r; r = uv_mutex_init(&mutex); - ASSERT_OK(r); + ASSERT(r == 0); uv_mutex_lock(&mutex); r = uv_prepare_init(uv_default_loop(), &prepare); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_prepare_start(&prepare, prepare_cb); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_async_init(uv_default_loop(), &async, async_cb); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_GT(prepare_cb_called, 0); - ASSERT_EQ(3, async_cb_called); - ASSERT_EQ(2, close_cb_called); + ASSERT(prepare_cb_called > 0); + ASSERT(async_cb_called == 3); + ASSERT(close_cb_called == 2); - ASSERT_OK(uv_thread_join(&thread)); + ASSERT(0 == uv_thread_join(&thread)); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-barrier.c b/test/test-barrier.c index 5e904c4..89858db 100644 --- a/test/test-barrier.c +++ b/test/test-barrier.c @@ -27,22 +27,20 @@ typedef struct { uv_barrier_t barrier; - unsigned delay; - unsigned niter; - unsigned main_barrier_wait_rval; - unsigned worker_barrier_wait_rval; + int delay; + volatile int posted; + int main_barrier_wait_rval; + int worker_barrier_wait_rval; } worker_config; static void worker(void* arg) { worker_config* c = arg; - unsigned i; if (c->delay) uv_sleep(c->delay); - for (i = 0; i < c->niter; i++) - c->worker_barrier_wait_rval += uv_barrier_wait(&c->barrier); + c->worker_barrier_wait_rval = uv_barrier_wait(&c->barrier); } @@ -51,18 +49,17 @@ TEST_IMPL(barrier_1) { worker_config wc; memset(&wc, 0, sizeof(wc)); - wc.niter = 1; - ASSERT_OK(uv_barrier_init(&wc.barrier, 2)); - ASSERT_OK(uv_thread_create(&thread, worker, &wc)); + ASSERT(0 == uv_barrier_init(&wc.barrier, 2)); + ASSERT(0 == uv_thread_create(&thread, worker, &wc)); uv_sleep(100); wc.main_barrier_wait_rval = uv_barrier_wait(&wc.barrier); - ASSERT_OK(uv_thread_join(&thread)); + ASSERT(0 == uv_thread_join(&thread)); uv_barrier_destroy(&wc.barrier); - ASSERT_EQ(1, (wc.main_barrier_wait_rval ^ wc.worker_barrier_wait_rval)); + ASSERT(1 == (wc.main_barrier_wait_rval ^ wc.worker_barrier_wait_rval)); return 0; } @@ -74,17 +71,16 @@ TEST_IMPL(barrier_2) { memset(&wc, 0, sizeof(wc)); wc.delay = 100; - wc.niter = 1; - ASSERT_OK(uv_barrier_init(&wc.barrier, 2)); - ASSERT_OK(uv_thread_create(&thread, worker, &wc)); + ASSERT(0 == uv_barrier_init(&wc.barrier, 2)); + ASSERT(0 == uv_thread_create(&thread, worker, &wc)); wc.main_barrier_wait_rval = uv_barrier_wait(&wc.barrier); - ASSERT_OK(uv_thread_join(&thread)); + ASSERT(0 == uv_thread_join(&thread)); uv_barrier_destroy(&wc.barrier); - ASSERT_EQ(1, (wc.main_barrier_wait_rval ^ wc.worker_barrier_wait_rval)); + ASSERT(1 == (wc.main_barrier_wait_rval ^ wc.worker_barrier_wait_rval)); return 0; } @@ -93,32 +89,26 @@ TEST_IMPL(barrier_2) { TEST_IMPL(barrier_3) { uv_thread_t thread; worker_config wc; - unsigned i; memset(&wc, 0, sizeof(wc)); - wc.niter = 5; - ASSERT_OK(uv_barrier_init(&wc.barrier, 2)); - ASSERT_OK(uv_thread_create(&thread, worker, &wc)); + ASSERT(0 == uv_barrier_init(&wc.barrier, 2)); + ASSERT(0 == uv_thread_create(&thread, worker, &wc)); - for (i = 0; i < wc.niter; i++) - wc.main_barrier_wait_rval += uv_barrier_wait(&wc.barrier); + wc.main_barrier_wait_rval = uv_barrier_wait(&wc.barrier); - ASSERT_OK(uv_thread_join(&thread)); + ASSERT(0 == uv_thread_join(&thread)); uv_barrier_destroy(&wc.barrier); - ASSERT_EQ(wc.niter, wc.main_barrier_wait_rval + wc.worker_barrier_wait_rval); + ASSERT(1 == (wc.main_barrier_wait_rval ^ wc.worker_barrier_wait_rval)); return 0; } static void serial_worker(void* data) { uv_barrier_t* barrier; - unsigned i; barrier = data; - for (i = 0; i < 5; i++) - uv_barrier_wait(barrier); if (uv_barrier_wait(barrier) > 0) uv_barrier_destroy(barrier); @@ -133,18 +123,16 @@ TEST_IMPL(barrier_serial_thread) { uv_barrier_t barrier; unsigned i; - ASSERT_OK(uv_barrier_init(&barrier, ARRAY_SIZE(threads) + 1)); + ASSERT(0 == uv_barrier_init(&barrier, ARRAY_SIZE(threads) + 1)); for (i = 0; i < ARRAY_SIZE(threads); ++i) - ASSERT_OK(uv_thread_create(&threads[i], serial_worker, &barrier)); + ASSERT(0 == uv_thread_create(&threads[i], serial_worker, &barrier)); - for (i = 0; i < 5; i++) - uv_barrier_wait(&barrier); if (uv_barrier_wait(&barrier) > 0) uv_barrier_destroy(&barrier); for (i = 0; i < ARRAY_SIZE(threads); ++i) - ASSERT_OK(uv_thread_join(&threads[i])); + ASSERT(0 == uv_thread_join(&threads[i])); return 0; } @@ -153,8 +141,8 @@ TEST_IMPL(barrier_serial_thread) { TEST_IMPL(barrier_serial_thread_single) { uv_barrier_t barrier; - ASSERT_OK(uv_barrier_init(&barrier, 1)); - ASSERT_LT(0, uv_barrier_wait(&barrier)); + ASSERT(0 == uv_barrier_init(&barrier, 1)); + ASSERT(0 < uv_barrier_wait(&barrier)); uv_barrier_destroy(&barrier); return 0; } diff --git a/test/test-callback-stack.c b/test/test-callback-stack.c index dfd102c..a5195c7 100644 --- a/test/test-callback-stack.c +++ b/test/test-callback-stack.c @@ -60,7 +60,7 @@ static void close_cb(uv_handle_t* handle) { static void shutdown_cb(uv_shutdown_t* req, int status) { - ASSERT_OK(status); + ASSERT(status == 0); ASSERT(nested == 0 && "shutdown_cb must be called from a fresh stack"); shutdown_cb_called++; @@ -77,7 +77,7 @@ static void read_cb(uv_stream_t* tcp, ssize_t nread, const uv_buf_t* buf) { return; } else if (nread < 0) { - ASSERT_EQ(nread, UV_EOF); + ASSERT(nread == UV_EOF); nested++; uv_close((uv_handle_t*)tcp, close_cb); @@ -105,7 +105,7 @@ static void read_cb(uv_stream_t* tcp, ssize_t nread, const uv_buf_t* buf) { static void timer_cb(uv_timer_t* handle) { - ASSERT_PTR_EQ(handle, &timer); + ASSERT(handle == &timer); ASSERT(nested == 0 && "timer_cb must be called from a fresh stack"); puts("Timeout complete. Now read data..."); @@ -125,7 +125,7 @@ static void timer_cb(uv_timer_t* handle) { static void write_cb(uv_write_t* req, int status) { int r; - ASSERT_OK(status); + ASSERT(status == 0); ASSERT(nested == 0 && "write_cb must be called from a fresh stack"); puts("Data written. 500ms timeout..."); @@ -136,9 +136,9 @@ static void write_cb(uv_write_t* req, int status) { * for the backend to use dirty stack for calling read_cb. */ nested++; r = uv_timer_init(uv_default_loop(), &timer); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_timer_start(&timer, timer_cb, 500, 0); - ASSERT_OK(r); + ASSERT(r == 0); nested--; write_cb_called++; @@ -150,7 +150,7 @@ static void connect_cb(uv_connect_t* req, int status) { puts("Connected. Write some data to echo server..."); - ASSERT_OK(status); + ASSERT(status == 0); ASSERT(nested == 0 && "connect_cb must be called from a fresh stack"); nested++; @@ -171,7 +171,7 @@ static void connect_cb(uv_connect_t* req, int status) { TEST_IMPL(callback_stack) { struct sockaddr_in addr; - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); + ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); if (uv_tcp_init(uv_default_loop(), &client)) { FATAL("uv_tcp_init failed"); @@ -191,19 +191,14 @@ TEST_IMPL(callback_stack) { uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_OK(nested); - ASSERT_NE(connect_cb_called == 1 && \ - "connect_cb must be called exactly once", 0); - ASSERT_NE(write_cb_called == 1 && "write_cb must be called exactly once", - 0); - ASSERT_NE(timer_cb_called == 1 && "timer_cb must be called exactly once", - 0); - ASSERT_EQ(bytes_received, sizeof MESSAGE); - ASSERT_NE(shutdown_cb_called == 1 && \ - "shutdown_cb must be called exactly once", 0); - ASSERT_NE(close_cb_called == 2 && "close_cb must be called exactly twice", - 0); - - MAKE_VALGRIND_HAPPY(uv_default_loop()); + ASSERT(nested == 0); + ASSERT(connect_cb_called == 1 && "connect_cb must be called exactly once"); + ASSERT(write_cb_called == 1 && "write_cb must be called exactly once"); + ASSERT(timer_cb_called == 1 && "timer_cb must be called exactly once"); + ASSERT(bytes_received == sizeof MESSAGE); + ASSERT(shutdown_cb_called == 1 && "shutdown_cb must be called exactly once"); + ASSERT(close_cb_called == 2 && "close_cb must be called exactly twice"); + + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-close-fd.c b/test/test-close-fd.c index c072fdb..6940ecc 100644 --- a/test/test-close-fd.c +++ b/test/test-close-fd.c @@ -36,15 +36,15 @@ static void alloc_cb(uv_handle_t* handle, size_t size, uv_buf_t* buf) { static void read_cb(uv_stream_t* handle, ssize_t nread, const uv_buf_t* buf) { switch (++read_cb_called) { case 1: - ASSERT_EQ(1, nread); + ASSERT(nread == 1); uv_read_stop(handle); break; case 2: - ASSERT_EQ(nread, UV_EOF); + ASSERT(nread == UV_EOF); uv_close((uv_handle_t *) handle, NULL); break; default: - ASSERT(!"read_cb_called > 2"); + ASSERT(!(read_cb_called > 2)); } } @@ -55,30 +55,30 @@ TEST_IMPL(close_fd) { uv_file fd[2]; bufs[0] = uv_buf_init("", 1); - ASSERT_OK(uv_pipe(fd, 0, 0)); - ASSERT_OK(uv_pipe_init(uv_default_loop(), &pipe_handle, 0)); - ASSERT_OK(uv_pipe_open(&pipe_handle, fd[0])); + ASSERT(0 == uv_pipe(fd, 0, 0)); + ASSERT(0 == uv_pipe_init(uv_default_loop(), &pipe_handle, 0)); + ASSERT(0 == uv_pipe_open(&pipe_handle, fd[0])); /* uv_pipe_open() takes ownership of the file descriptor. */ fd[0] = -1; - ASSERT_EQ(1, uv_fs_write(NULL, &req, fd[1], bufs, 1, -1, NULL)); - ASSERT_EQ(1, req.result); + ASSERT(1 == uv_fs_write(NULL, &req, fd[1], bufs, 1, -1, NULL)); + ASSERT(1 == req.result); uv_fs_req_cleanup(&req); #ifdef _WIN32 - ASSERT_OK(_close(fd[1])); + ASSERT(0 == _close(fd[1])); #else - ASSERT_OK(close(fd[1])); + ASSERT(0 == close(fd[1])); #endif fd[1] = -1; - ASSERT_OK(uv_read_start((uv_stream_t *) &pipe_handle, alloc_cb, read_cb)); - ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT)); - ASSERT_EQ(1, read_cb_called); - ASSERT_OK(uv_is_active((const uv_handle_t *) &pipe_handle)); - ASSERT_OK(uv_read_start((uv_stream_t *) &pipe_handle, alloc_cb, read_cb)); - ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT)); - ASSERT_EQ(2, read_cb_called); - ASSERT_NE(0, uv_is_closing((const uv_handle_t *) &pipe_handle)); + ASSERT(0 == uv_read_start((uv_stream_t *) &pipe_handle, alloc_cb, read_cb)); + ASSERT(0 == uv_run(uv_default_loop(), UV_RUN_DEFAULT)); + ASSERT(1 == read_cb_called); + ASSERT(0 == uv_is_active((const uv_handle_t *) &pipe_handle)); + ASSERT(0 == uv_read_start((uv_stream_t *) &pipe_handle, alloc_cb, read_cb)); + ASSERT(0 == uv_run(uv_default_loop(), UV_RUN_DEFAULT)); + ASSERT(2 == read_cb_called); + ASSERT(0 != uv_is_closing((const uv_handle_t *) &pipe_handle)); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-close-order.c b/test/test-close-order.c index e1aae93..c2fd6c3 100644 --- a/test/test-close-order.c +++ b/test/test-close-order.c @@ -39,9 +39,9 @@ static void close_cb(uv_handle_t* handle) { /* check_cb should run before any close_cb */ static void check_cb(uv_check_t* handle) { - ASSERT_OK(check_cb_called); - ASSERT_EQ(1, timer_cb_called); - ASSERT_OK(close_cb_called); + ASSERT(check_cb_called == 0); + ASSERT(timer_cb_called == 1); + ASSERT(close_cb_called == 0); uv_close((uv_handle_t*) handle, close_cb); uv_close((uv_handle_t*) &timer_handle2, close_cb); check_cb_called++; @@ -65,16 +65,16 @@ TEST_IMPL(close_order) { uv_timer_init(loop, &timer_handle2); uv_timer_start(&timer_handle2, timer_cb, 100000, 0); - ASSERT_OK(check_cb_called); - ASSERT_OK(close_cb_called); - ASSERT_OK(timer_cb_called); + ASSERT(check_cb_called == 0); + ASSERT(close_cb_called == 0); + ASSERT(timer_cb_called == 0); uv_run(loop, UV_RUN_DEFAULT); - ASSERT_EQ(1, check_cb_called); - ASSERT_EQ(3, close_cb_called); - ASSERT_EQ(1, timer_cb_called); + ASSERT(check_cb_called == 1); + ASSERT(close_cb_called == 3); + ASSERT(timer_cb_called == 1); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-condvar.c b/test/test-condvar.c index 2711f8c..32abccc 100644 --- a/test/test-condvar.c +++ b/test/test-condvar.c @@ -55,10 +55,10 @@ void worker_config_init(worker_config* wc, wc->use_broadcast = use_broadcast; /* Init. */ - ASSERT_OK(uv_sem_init(&wc->sem_waiting, 0)); - ASSERT_OK(uv_sem_init(&wc->sem_signaled, 0)); - ASSERT_OK(uv_cond_init(&wc->cond)); - ASSERT_OK(uv_mutex_init(&wc->mutex)); + ASSERT(0 == uv_sem_init(&wc->sem_waiting, 0)); + ASSERT(0 == uv_sem_init(&wc->sem_signaled, 0)); + ASSERT(0 == uv_cond_init(&wc->cond)); + ASSERT(0 == uv_mutex_init(&wc->mutex)); } void worker_config_destroy(worker_config* wc) { @@ -87,7 +87,7 @@ static void condvar_signal(worker_config* c, int* flag) { uv_mutex_lock(&c->mutex); /* Help waiter differentiate between spurious and legitimate wakeup. */ - ASSERT_OK(*flag); + ASSERT(*flag == 0); *flag = 1; if (c->use_broadcast) @@ -113,7 +113,7 @@ static int condvar_wait(worker_config* c, const int* flag) { do { uv_cond_wait(&c->cond, &c->mutex); } while (*flag == 0); - ASSERT_EQ(1, *flag); + ASSERT(*flag == 1); uv_mutex_unlock(&c->mutex); @@ -130,13 +130,13 @@ TEST_IMPL(condvar_1) { /* Helper signal-then-wait. */ worker_config_init(&wc, 0, condvar_signal, condvar_wait); - ASSERT_OK(uv_thread_create(&thread, worker, &wc)); + ASSERT(0 == uv_thread_create(&thread, worker, &wc)); /* We wait-then-signal. */ - ASSERT_OK(wc.wait_cond(&wc, &wc.posted_1)); + ASSERT(0 == wc.wait_cond(&wc, &wc.posted_1)); wc.signal_cond(&wc, &wc.posted_2); - ASSERT_OK(uv_thread_join(&thread)); + ASSERT(0 == uv_thread_join(&thread)); worker_config_destroy(&wc); return 0; @@ -149,13 +149,13 @@ TEST_IMPL(condvar_2) { /* Helper to signal-then-wait. */ worker_config_init(&wc, 1, condvar_signal, condvar_wait); - ASSERT_OK(uv_thread_create(&thread, worker, &wc)); + ASSERT(0 == uv_thread_create(&thread, worker, &wc)); /* We wait-then-signal. */ - ASSERT_OK(wc.wait_cond(&wc, &wc.posted_1)); + ASSERT(0 == wc.wait_cond(&wc, &wc.posted_1)); wc.signal_cond(&wc, &wc.posted_2); - ASSERT_OK(uv_thread_join(&thread)); + ASSERT(0 == uv_thread_join(&thread)); worker_config_destroy(&wc); return 0; @@ -176,9 +176,9 @@ static int condvar_timedwait(worker_config* c, const int* flag) { /* Wait until I get a non-spurious signal. */ do { r = uv_cond_timedwait(&c->cond, &c->mutex, (uint64_t)(1 * 1e9)); /* 1 s */ - ASSERT_OK(r); /* Should not time out. */ + ASSERT(r == 0); /* Should not time out. */ } while (*flag == 0); - ASSERT_EQ(1, *flag); + ASSERT(*flag == 1); uv_mutex_unlock(&c->mutex); @@ -194,13 +194,13 @@ TEST_IMPL(condvar_3) { /* Helper to signal-then-wait. */ worker_config_init(&wc, 0, condvar_signal, condvar_timedwait); - ASSERT_OK(uv_thread_create(&thread, worker, &wc)); + ASSERT(0 == uv_thread_create(&thread, worker, &wc)); /* We wait-then-signal. */ wc.wait_cond(&wc, &wc.posted_1); wc.signal_cond(&wc, &wc.posted_2); - ASSERT_OK(uv_thread_join(&thread)); + ASSERT(0 == uv_thread_join(&thread)); worker_config_destroy(&wc); return 0; @@ -213,13 +213,13 @@ TEST_IMPL(condvar_4) { /* Helper to signal-then-wait. */ worker_config_init(&wc, 1, condvar_signal, condvar_timedwait); - ASSERT_OK(uv_thread_create(&thread, worker, &wc)); + ASSERT(0 == uv_thread_create(&thread, worker, &wc)); /* We wait-then-signal. */ wc.wait_cond(&wc, &wc.posted_1); wc.signal_cond(&wc, &wc.posted_2); - ASSERT_OK(uv_thread_join(&thread)); + ASSERT(0 == uv_thread_join(&thread)); worker_config_destroy(&wc); return 0; @@ -228,6 +228,11 @@ TEST_IMPL(condvar_4) { /* uv_cond_timedwait: One thread waits, no signal. Timeout should be delivered. */ TEST_IMPL(condvar_5) { worker_config wc; + int r; + /* ns */ + uint64_t before; + uint64_t after; + uint64_t elapsed; uint64_t timeout; timeout = 100 * 1000 * 1000; /* 100 ms in ns */ @@ -237,11 +242,25 @@ TEST_IMPL(condvar_5) { uv_mutex_lock(&wc.mutex); - /* We wait. No signaler, so this will only return if timeout is delivered. */ - ASSERT_EQ(UV_ETIMEDOUT, uv_cond_timedwait(&wc.cond, &wc.mutex, timeout)); + /* We wait. + * No signaler, so this will only return if timeout is delivered. */ + before = uv_hrtime(); + r = uv_cond_timedwait(&wc.cond, &wc.mutex, timeout); + after = uv_hrtime(); uv_mutex_unlock(&wc.mutex); + /* It timed out. */ + ASSERT(r == UV_ETIMEDOUT); + + /* It must have taken at least timeout, modulo system timer ticks. + * But it should not take too much longer. + * cf. MSDN docs: + * https://msdn.microsoft.com/en-us/library/ms687069(VS.85).aspx */ + elapsed = after - before; + ASSERT(0.75 * timeout <= elapsed); /* 1.0 too large for Windows. */ + ASSERT(elapsed <= 5.0 * timeout); /* MacOS has reported failures up to 1.75. */ + worker_config_destroy(&wc); return 0; diff --git a/test/test-connect-unspecified.c b/test/test-connect-unspecified.c index 73e59a9..5f32b67 100644 --- a/test/test-connect-unspecified.c +++ b/test/test-connect-unspecified.c @@ -23,11 +23,11 @@ #include "task.h" static void connect_4(uv_connect_t* req, int status) { - ASSERT_NE(status, UV_EADDRNOTAVAIL); + ASSERT(status != UV_EADDRNOTAVAIL); } static void connect_6(uv_connect_t* req, int status) { - ASSERT_NE(status, UV_EADDRNOTAVAIL); + ASSERT(status != UV_EADDRNOTAVAIL); } TEST_IMPL(connect_unspecified) { @@ -41,24 +41,23 @@ TEST_IMPL(connect_unspecified) { loop = uv_default_loop(); - ASSERT_OK(uv_tcp_init(loop, &socket4)); - ASSERT_OK(uv_ip4_addr("0.0.0.0", TEST_PORT, &addr4)); - ASSERT_OK(uv_tcp_connect(&connect4, - &socket4, - (const struct sockaddr*) &addr4, - connect_4)); + ASSERT(uv_tcp_init(loop, &socket4) == 0); + ASSERT(uv_ip4_addr("0.0.0.0", TEST_PORT, &addr4) == 0); + ASSERT(uv_tcp_connect(&connect4, + &socket4, + (const struct sockaddr*) &addr4, + connect_4) == 0); if (can_ipv6()) { - ASSERT_OK(uv_tcp_init(loop, &socket6)); - ASSERT_OK(uv_ip6_addr("::", TEST_PORT, &addr6)); - ASSERT_OK(uv_tcp_connect(&connect6, - &socket6, - (const struct sockaddr*) &addr6, - connect_6)); + ASSERT(uv_tcp_init(loop, &socket6) == 0); + ASSERT(uv_ip6_addr("::", TEST_PORT, &addr6) == 0); + ASSERT(uv_tcp_connect(&connect6, + &socket6, + (const struct sockaddr*) &addr6, + connect_6) == 0); } - ASSERT_OK(uv_run(loop, UV_RUN_DEFAULT)); + ASSERT(uv_run(loop, UV_RUN_DEFAULT) == 0); - MAKE_VALGRIND_HAPPY(loop); return 0; } diff --git a/test/test-connection-fail.c b/test/test-connection-fail.c index 9efd3ac..5904810 100644 --- a/test/test-connection-fail.c +++ b/test/test-connection-fail.c @@ -54,8 +54,8 @@ static void timer_cb(uv_timer_t* handle) { * but libuv hasn't automatically closed the socket. The user must * uv_close the handle manually. */ - ASSERT_OK(close_cb_calls); - ASSERT_EQ(1, connect_cb_calls); + ASSERT(close_cb_calls == 0); + ASSERT(connect_cb_calls == 1); /* Close the tcp handle. */ uv_close((uv_handle_t*)&tcp, on_close); @@ -66,22 +66,22 @@ static void timer_cb(uv_timer_t* handle) { static void on_connect_with_close(uv_connect_t *req, int status) { - ASSERT_PTR_EQ((uv_stream_t*) &tcp, req->handle); - ASSERT_EQ(status, UV_ECONNREFUSED); + ASSERT((uv_stream_t*) &tcp == req->handle); + ASSERT(status == UV_ECONNREFUSED); connect_cb_calls++; - ASSERT_OK(close_cb_calls); + ASSERT(close_cb_calls == 0); uv_close((uv_handle_t*)req->handle, on_close); } static void on_connect_without_close(uv_connect_t *req, int status) { - ASSERT_EQ(status, UV_ECONNREFUSED); + ASSERT(status == UV_ECONNREFUSED); connect_cb_calls++; uv_timer_start(&timer, timer_cb, 100, 0); - ASSERT_OK(close_cb_calls); + ASSERT(close_cb_calls == 0); } @@ -89,10 +89,10 @@ static void connection_fail(uv_connect_cb connect_cb) { struct sockaddr_in client_addr, server_addr; int r; - ASSERT_OK(uv_ip4_addr("0.0.0.0", 0, &client_addr)); + ASSERT(0 == uv_ip4_addr("0.0.0.0", 0, &client_addr)); /* There should be no servers listening on this port. */ - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &server_addr)); + ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &server_addr)); /* Try to connect to the server and do NUM_PINGS ping-pongs. */ r = uv_tcp_init(uv_default_loop(), &tcp); @@ -100,7 +100,7 @@ static void connection_fail(uv_connect_cb connect_cb) { /* We are never doing multiple reads/connects at a time anyway. so these * handles can be pre-initialized. */ - ASSERT_OK(uv_tcp_bind(&tcp, (const struct sockaddr*) &client_addr, 0)); + ASSERT(0 == uv_tcp_bind(&tcp, (const struct sockaddr*) &client_addr, 0)); r = uv_tcp_connect(&req, &tcp, @@ -110,8 +110,8 @@ static void connection_fail(uv_connect_cb connect_cb) { uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_EQ(1, connect_cb_calls); - ASSERT_EQ(1, close_cb_calls); + ASSERT(connect_cb_calls == 1); + ASSERT(close_cb_calls == 1); } @@ -127,10 +127,10 @@ TEST_IMPL(connection_fail) { connection_fail(on_connect_with_close); - ASSERT_OK(timer_close_cb_calls); - ASSERT_OK(timer_cb_calls); + ASSERT(timer_close_cb_calls == 0); + ASSERT(timer_cb_calls == 0); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -149,13 +149,13 @@ TEST_IMPL(connection_fail_doesnt_auto_close) { int r; r = uv_timer_init(uv_default_loop(), &timer); - ASSERT_OK(r); + ASSERT(r == 0); connection_fail(on_connect_without_close); - ASSERT_EQ(1, timer_close_cb_calls); - ASSERT_EQ(1, timer_cb_calls); + ASSERT(timer_close_cb_calls == 1); + ASSERT(timer_cb_calls == 1); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-cwd-and-chdir.c b/test/test-cwd-and-chdir.c index e4a0eef..faeed02 100644 --- a/test/test-cwd-and-chdir.c +++ b/test/test-cwd-and-chdir.c @@ -34,24 +34,24 @@ TEST_IMPL(cwd_and_chdir) { size1 = 1; err = uv_cwd(buffer_orig, &size1); - ASSERT_EQ(err, UV_ENOBUFS); - ASSERT_GT(size1, 1); + ASSERT(err == UV_ENOBUFS); + ASSERT(size1 > 1); size1 = sizeof buffer_orig; err = uv_cwd(buffer_orig, &size1); - ASSERT_OK(err); - ASSERT_GT(size1, 0); - ASSERT_NE(buffer_orig[size1], '/'); + ASSERT(err == 0); + ASSERT(size1 > 0); + ASSERT(buffer_orig[size1] != '/'); err = uv_chdir(buffer_orig); - ASSERT_OK(err); + ASSERT(err == 0); size2 = sizeof buffer_new; err = uv_cwd(buffer_new, &size2); - ASSERT_OK(err); + ASSERT(err == 0); - ASSERT_EQ(size1, size2); - ASSERT_OK(strcmp(buffer_orig, buffer_new)); + ASSERT(size1 == size2); + ASSERT(strcmp(buffer_orig, buffer_new) == 0); return 0; } diff --git a/test/test-default-loop-close.c b/test/test-default-loop-close.c index d08a33e..51e1e7d 100644 --- a/test/test-default-loop-close.c +++ b/test/test-default-loop-close.c @@ -39,20 +39,21 @@ TEST_IMPL(default_loop_close) { loop = uv_default_loop(); ASSERT_NOT_NULL(loop); - ASSERT_OK(uv_timer_init(loop, &timer_handle)); - ASSERT_OK(uv_timer_start(&timer_handle, timer_cb, 1, 0)); - ASSERT_OK(uv_run(loop, UV_RUN_DEFAULT)); - ASSERT_EQ(1, timer_cb_called); - ASSERT_OK(uv_loop_close(loop)); + ASSERT(0 == uv_timer_init(loop, &timer_handle)); + ASSERT(0 == uv_timer_start(&timer_handle, timer_cb, 1, 0)); + ASSERT(0 == uv_run(loop, UV_RUN_DEFAULT)); + ASSERT(1 == timer_cb_called); + ASSERT(0 == uv_loop_close(loop)); loop = uv_default_loop(); ASSERT_NOT_NULL(loop); - ASSERT_OK(uv_timer_init(loop, &timer_handle)); - ASSERT_OK(uv_timer_start(&timer_handle, timer_cb, 1, 0)); - ASSERT_OK(uv_run(loop, UV_RUN_DEFAULT)); - ASSERT_EQ(2, timer_cb_called); + ASSERT(0 == uv_timer_init(loop, &timer_handle)); + ASSERT(0 == uv_timer_start(&timer_handle, timer_cb, 1, 0)); + ASSERT(0 == uv_run(loop, UV_RUN_DEFAULT)); + ASSERT(2 == timer_cb_called); + ASSERT(0 == uv_loop_close(loop)); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-delayed-accept.c b/test/test-delayed-accept.c index f7cf80a..88b31e2 100644 --- a/test/test-delayed-accept.c +++ b/test/test-delayed-accept.c @@ -54,11 +54,11 @@ static void do_accept(uv_timer_t* timer_handle) { ASSERT_NOT_NULL(accepted_handle); r = uv_tcp_init(uv_default_loop(), accepted_handle); - ASSERT_OK(r); + ASSERT(r == 0); server = (uv_tcp_t*)timer_handle->data; r = uv_accept((uv_stream_t*)server, (uv_stream_t*)accepted_handle); - ASSERT_OK(r); + ASSERT(r == 0); do_accept_called++; @@ -79,19 +79,19 @@ static void connection_cb(uv_stream_t* tcp, int status) { int r; uv_timer_t* timer_handle; - ASSERT_OK(status); + ASSERT(status == 0); timer_handle = (uv_timer_t*)malloc(sizeof *timer_handle); ASSERT_NOT_NULL(timer_handle); /* Accept the client after 1 second */ r = uv_timer_init(uv_default_loop(), timer_handle); - ASSERT_OK(r); + ASSERT(r == 0); timer_handle->data = tcp; r = uv_timer_start(timer_handle, do_accept, 1000, 0); - ASSERT_OK(r); + ASSERT(r == 0); connection_cb_called++; } @@ -102,16 +102,16 @@ static void start_server(void) { uv_tcp_t* server = (uv_tcp_t*)malloc(sizeof *server); int r; - ASSERT_OK(uv_ip4_addr("0.0.0.0", TEST_PORT, &addr)); + ASSERT(0 == uv_ip4_addr("0.0.0.0", TEST_PORT, &addr)); ASSERT_NOT_NULL(server); r = uv_tcp_init(uv_default_loop(), server); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_tcp_bind(server, (const struct sockaddr*) &addr, 0); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_listen((uv_stream_t*)server, 128, connection_cb); - ASSERT_OK(r); + ASSERT(r == 0); } @@ -123,10 +123,10 @@ static void read_cb(uv_stream_t* tcp, ssize_t nread, const uv_buf_t* buf) { } if (nread >= 0) { - ASSERT_OK(nread); + ASSERT(nread == 0); } else { ASSERT_NOT_NULL(tcp); - ASSERT_EQ(nread, UV_EOF); + ASSERT(nread == UV_EOF); uv_close((uv_handle_t*)tcp, close_cb); } } @@ -136,12 +136,12 @@ static void connect_cb(uv_connect_t* req, int status) { int r; ASSERT_NOT_NULL(req); - ASSERT_OK(status); + ASSERT(status == 0); /* Not that the server will send anything, but otherwise we'll never know * when the server closes the connection. */ r = uv_read_start((uv_stream_t*)(req->handle), alloc_cb, read_cb); - ASSERT_OK(r); + ASSERT(r == 0); connect_cb_called++; @@ -155,18 +155,18 @@ static void client_connect(void) { uv_connect_t* connect_req = malloc(sizeof *connect_req); int r; - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); + ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); ASSERT_NOT_NULL(client); ASSERT_NOT_NULL(connect_req); r = uv_tcp_init(uv_default_loop(), client); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_tcp_connect(connect_req, client, (const struct sockaddr*) &addr, connect_cb); - ASSERT_OK(r); + ASSERT(r == 0); } @@ -179,11 +179,11 @@ TEST_IMPL(delayed_accept) { uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_EQ(2, connection_cb_called); - ASSERT_EQ(2, do_accept_called); - ASSERT_EQ(2, connect_cb_called); - ASSERT_EQ(7, close_cb_called); + ASSERT(connection_cb_called == 2); + ASSERT(do_accept_called == 2); + ASSERT(connect_cb_called == 2); + ASSERT(close_cb_called == 7); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-dlerror.c b/test/test-dlerror.c index dec0da3..dd3f2c4 100644 --- a/test/test-dlerror.c +++ b/test/test-dlerror.c @@ -38,26 +38,7 @@ TEST_IMPL(dlerror) { ASSERT_NOT_NULL(strstr(msg, dlerror_no_error)); r = uv_dlopen(path, &lib); - ASSERT_EQ(r, -1); - - msg = uv_dlerror(&lib); - ASSERT_NOT_NULL(msg); -#if !defined(__OpenBSD__) && !defined(__QNX__) - /* musl's libc.a does not support dlopen(), only libc.so does. */ - if (NULL == strstr(msg, "Dynamic loading not supported")) - ASSERT_NOT_NULL(strstr(msg, path)); -#endif - ASSERT_NULL(strstr(msg, dlerror_no_error)); - - /* Should return the same error twice in a row. */ - msg = uv_dlerror(&lib); - ASSERT_NOT_NULL(msg); -#if !defined(__OpenBSD__) && !defined(__QNX__) - /* musl's libc.a does not support dlopen(), only libc.so does. */ - if (NULL == strstr(msg, "Dynamic loading not supported")) - ASSERT_NOT_NULL(strstr(msg, path)); -#endif - ASSERT_NULL(strstr(msg, dlerror_no_error)); + ASSERT(r == 0); uv_dlclose(&lib); diff --git a/test/test-eintr-handling.c b/test/test-eintr-handling.c index 1f75e77..1aaf623 100644 --- a/test/test-eintr-handling.c +++ b/test/test-eintr-handling.c @@ -48,13 +48,13 @@ struct thread_ctx { static void thread_main(void* arg) { int nwritten; - ASSERT_OK(kill(getpid(), SIGUSR1)); + ASSERT(0 == kill(getpid(), SIGUSR1)); do nwritten = write(pipe_fds[1], test_buf, sizeof(test_buf)); while (nwritten == -1 && errno == EINTR); - ASSERT_EQ(nwritten, sizeof(test_buf)); + ASSERT(nwritten == sizeof(test_buf)); } static void sig_func(uv_signal_t* handle, int signum) { @@ -70,26 +70,24 @@ TEST_IMPL(eintr_handling) { iov = uv_buf_init(buf, sizeof(buf)); loop = uv_default_loop(); - ASSERT_OK(uv_signal_init(loop, &signal)); - ASSERT_OK(uv_signal_start(&signal, sig_func, SIGUSR1)); + ASSERT(0 == uv_signal_init(loop, &signal)); + ASSERT(0 == uv_signal_start(&signal, sig_func, SIGUSR1)); - ASSERT_OK(pipe(pipe_fds)); - ASSERT_OK(uv_thread_create(&thread, thread_main, &ctx)); + ASSERT(0 == pipe(pipe_fds)); + ASSERT(0 == uv_thread_create(&thread, thread_main, &ctx)); nread = uv_fs_read(loop, &read_req, pipe_fds[0], &iov, 1, -1, NULL); - ASSERT_EQ(nread, sizeof(test_buf)); - ASSERT_OK(strcmp(buf, test_buf)); + ASSERT(nread == sizeof(test_buf)); + ASSERT(0 == strcmp(buf, test_buf)); - ASSERT_OK(uv_run(loop, UV_RUN_DEFAULT)); + ASSERT(0 == uv_run(loop, UV_RUN_DEFAULT)); - ASSERT_OK(close(pipe_fds[0])); - ASSERT_OK(close(pipe_fds[1])); + ASSERT(0 == close(pipe_fds[0])); + ASSERT(0 == close(pipe_fds[1])); uv_close((uv_handle_t*) &signal, NULL); - ASSERT_OK(uv_thread_join(&thread)); - - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-embed.c b/test/test-embed.c index 6e99172..1d3355f 100644 --- a/test/test-embed.c +++ b/test/test-embed.c @@ -36,7 +36,7 @@ static uv_barrier_t barrier; static void thread_main(void* arg) { ASSERT_LE(0, uv_barrier_wait(&barrier)); uv_sleep(250); - ASSERT_OK(uv_async_send(&async)); + ASSERT_EQ(0, uv_async_send(&async)); } @@ -50,9 +50,9 @@ TEST_IMPL(embed) { uv_loop_t* loop; loop = uv_default_loop(); - ASSERT_OK(uv_async_init(loop, &async, async_cb)); - ASSERT_OK(uv_barrier_init(&barrier, 2)); - ASSERT_OK(uv_thread_create(&thread, thread_main, NULL)); + ASSERT_EQ(0, uv_async_init(loop, &async, async_cb)); + ASSERT_EQ(0, uv_barrier_init(&barrier, 2)); + ASSERT_EQ(0, uv_thread_create(&thread, thread_main, NULL)); ASSERT_LE(0, uv_barrier_wait(&barrier)); while (uv_loop_alive(loop)) { @@ -71,9 +71,9 @@ TEST_IMPL(embed) { #endif } - ASSERT_OK(uv_thread_join(&thread)); + ASSERT_EQ(0, uv_thread_join(&thread)); uv_barrier_destroy(&barrier); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-emfile.c b/test/test-emfile.c index ef2338c..bc1fce5 100644 --- a/test/test-emfile.c +++ b/test/test-emfile.c @@ -54,37 +54,37 @@ TEST_IMPL(emfile) { /* Lower the file descriptor limit and use up all fds save one. */ limits.rlim_cur = limits.rlim_max = maxfd + 1; if (setrlimit(RLIMIT_NOFILE, &limits)) { - ASSERT_EQ(errno, EPERM); /* Valgrind blocks the setrlimit() call. */ + ASSERT(errno == EPERM); /* Valgrind blocks the setrlimit() call. */ RETURN_SKIP("setrlimit(RLIMIT_NOFILE) failed, running under valgrind?"); } loop = uv_default_loop(); - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); - ASSERT_OK(uv_tcp_init(loop, &server_handle)); - ASSERT_OK(uv_tcp_init(loop, &client_handle)); - ASSERT_OK(uv_tcp_bind(&server_handle, (const struct sockaddr*) &addr, 0)); - ASSERT_OK(uv_listen((uv_stream_t*) &server_handle, 8, connection_cb)); + ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); + ASSERT(0 == uv_tcp_init(loop, &server_handle)); + ASSERT(0 == uv_tcp_init(loop, &client_handle)); + ASSERT(0 == uv_tcp_bind(&server_handle, (const struct sockaddr*) &addr, 0)); + ASSERT(0 == uv_listen((uv_stream_t*) &server_handle, 8, connection_cb)); /* Remember the first one so we can clean up afterwards. */ do first_fd = dup(0); while (first_fd == -1 && errno == EINTR); - ASSERT_GT(first_fd, 0); + ASSERT(first_fd > 0); while (dup(0) != -1 || errno == EINTR); - ASSERT_EQ(errno, EMFILE); + ASSERT(errno == EMFILE); close(maxfd); /* Now connect and use up the last available file descriptor. The EMFILE * handling logic in src/unix/stream.c should ensure that connect_cb() runs * whereas connection_cb() should *not* run. */ - ASSERT_OK(uv_tcp_connect(&connect_req, - &client_handle, - (const struct sockaddr*) &addr, - connect_cb)); - ASSERT_OK(uv_run(loop, UV_RUN_DEFAULT)); - ASSERT_EQ(1, connect_cb_called); + ASSERT(0 == uv_tcp_connect(&connect_req, + &client_handle, + (const struct sockaddr*) &addr, + connect_cb)); + ASSERT(0 == uv_run(loop, UV_RUN_DEFAULT)); + ASSERT(1 == connect_cb_called); /* Close the dups again. Ignore errors in the unlikely event that the * file descriptors were not contiguous. @@ -94,7 +94,7 @@ TEST_IMPL(emfile) { first_fd += 1; } - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -108,7 +108,7 @@ static void connect_cb(uv_connect_t* req, int status) { /* |status| should equal 0 because the connection should have been accepted, * it's just that the server immediately closes it again. */ - ASSERT_OK(status); + ASSERT(0 == status); connect_cb_called += 1; uv_close((uv_handle_t*) &server_handle, NULL); uv_close((uv_handle_t*) &client_handle, NULL); diff --git a/test/test-env-vars.c b/test/test-env-vars.c index 016f073..ecaba33 100644 --- a/test/test-env-vars.c +++ b/test/test-env-vars.c @@ -35,83 +35,83 @@ TEST_IMPL(env_vars) { /* Reject invalid inputs when setting an environment variable */ r = uv_os_setenv(NULL, "foo"); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); r = uv_os_setenv(name, NULL); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); r = uv_os_setenv(NULL, NULL); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); /* Reject invalid inputs when retrieving an environment variable */ size = BUF_SIZE; r = uv_os_getenv(NULL, buf, &size); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); r = uv_os_getenv(name, NULL, &size); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); r = uv_os_getenv(name, buf, NULL); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); size = 0; r = uv_os_getenv(name, buf, &size); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); /* Reject invalid inputs when deleting an environment variable */ r = uv_os_unsetenv(NULL); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); /* Successfully set an environment variable */ r = uv_os_setenv(name, "123456789"); - ASSERT_OK(r); + ASSERT(r == 0); /* Successfully read an environment variable */ size = BUF_SIZE; buf[0] = '\0'; r = uv_os_getenv(name, buf, &size); - ASSERT_OK(r); - ASSERT_OK(strcmp(buf, "123456789")); - ASSERT_EQ(size, BUF_SIZE - 1); + ASSERT(r == 0); + ASSERT(strcmp(buf, "123456789") == 0); + ASSERT(size == BUF_SIZE - 1); /* Return UV_ENOBUFS if the buffer cannot hold the environment variable */ size = BUF_SIZE - 1; buf[0] = '\0'; r = uv_os_getenv(name, buf, &size); - ASSERT_EQ(r, UV_ENOBUFS); - ASSERT_EQ(size, BUF_SIZE); + ASSERT(r == UV_ENOBUFS); + ASSERT(size == BUF_SIZE); /* Successfully delete an environment variable */ r = uv_os_unsetenv(name); - ASSERT_OK(r); + ASSERT(r == 0); /* Return UV_ENOENT retrieving an environment variable that does not exist */ r = uv_os_getenv(name, buf, &size); - ASSERT_EQ(r, UV_ENOENT); + ASSERT(r == UV_ENOENT); /* Successfully delete an environment variable that does not exist */ r = uv_os_unsetenv(name); - ASSERT_OK(r); + ASSERT(r == 0); /* Setting an environment variable to the empty string does not delete it. */ r = uv_os_setenv(name, ""); - ASSERT_OK(r); + ASSERT(r == 0); size = BUF_SIZE; r = uv_os_getenv(name, buf, &size); - ASSERT_OK(r); - ASSERT_OK(size); - ASSERT_OK(strlen(buf)); + ASSERT(r == 0); + ASSERT(size == 0); + ASSERT(strlen(buf) == 0); /* Check getting all env variables. */ r = uv_os_setenv(name, "123456789"); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_os_setenv(name2, ""); - ASSERT_OK(r); + ASSERT(r == 0); #ifdef _WIN32 /* Create a special environment variable on Windows in case there are no naturally occurring ones. */ r = uv_os_setenv("=Z:", "\\"); - ASSERT_OK(r); + ASSERT(r == 0); #endif r = uv_os_environ(&envitems, &envcount); - ASSERT_OK(r); - ASSERT_GT(envcount, 0); + ASSERT(r == 0); + ASSERT(envcount > 0); found = 0; found_win_special = 0; @@ -120,30 +120,27 @@ TEST_IMPL(env_vars) { /* printf("Env: %s = %s\n", envitems[i].name, envitems[i].value); */ if (strcmp(envitems[i].name, name) == 0) { found++; - ASSERT_OK(strcmp(envitems[i].value, "123456789")); + ASSERT(strcmp(envitems[i].value, "123456789") == 0); } else if (strcmp(envitems[i].name, name2) == 0) { found++; - ASSERT_OK(strlen(envitems[i].value)); + ASSERT(strlen(envitems[i].value) == 0); } else if (envitems[i].name[0] == '=') { found_win_special++; } } - ASSERT_EQ(2, found); + ASSERT(found == 2); #ifdef _WIN32 - ASSERT_GT(found_win_special, 0); -#else - /* There's no rule saying a key can't start with '='. */ - (void) &found_win_special; + ASSERT(found_win_special > 0); #endif uv_os_free_environ(envitems, envcount); r = uv_os_unsetenv(name); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_os_unsetenv(name2); - ASSERT_OK(r); + ASSERT(r == 0); for (i = 1; i <= 4; i++) { size_t n; @@ -158,14 +155,14 @@ TEST_IMPL(env_vars) { memset(p, 'x', n); p[n] = '\0'; - ASSERT_OK(uv_os_setenv(name, p)); - ASSERT_OK(uv_os_getenv(name, p, &size)); + ASSERT_EQ(0, uv_os_setenv(name, p)); + ASSERT_EQ(0, uv_os_getenv(name, p, &size)); ASSERT_EQ(n, size); for (n = 0; n < size; n++) ASSERT_EQ('x', p[n]); - ASSERT_OK(uv_os_unsetenv(name)); + ASSERT_EQ(0, uv_os_unsetenv(name)); free(p); } diff --git a/test/test-error.c b/test/test-error.c index 2c6d0ca..f0fb864 100644 --- a/test/test-error.c +++ b/test/test-error.c @@ -51,8 +51,8 @@ TEST_IMPL(error_message) { } ASSERT_NULL(strstr(uv_strerror(UV_EINVAL), "Success")); - ASSERT_OK(strcmp(uv_strerror(1337), "Unknown error")); - ASSERT_OK(strcmp(uv_strerror(-1337), "Unknown error")); + ASSERT(strcmp(uv_strerror(1337), "Unknown error") == 0); + ASSERT(strcmp(uv_strerror(-1337), "Unknown error") == 0); ASSERT_NULL(strstr(uv_strerror_r(UV_EINVAL, buf, sizeof(buf)), "Success")); ASSERT_NOT_NULL(strstr(uv_strerror_r(1337, buf, sizeof(buf)), "1337")); @@ -64,19 +64,19 @@ TEST_IMPL(error_message) { TEST_IMPL(sys_error) { #if defined(_WIN32) - ASSERT_EQ(uv_translate_sys_error(ERROR_NOACCESS), UV_EACCES); - ASSERT_EQ(uv_translate_sys_error(ERROR_ELEVATION_REQUIRED), UV_EACCES); - ASSERT_EQ(uv_translate_sys_error(WSAEADDRINUSE), UV_EADDRINUSE); - ASSERT_EQ(uv_translate_sys_error(ERROR_BAD_PIPE), UV_EPIPE); + ASSERT(uv_translate_sys_error(ERROR_NOACCESS) == UV_EACCES); + ASSERT(uv_translate_sys_error(ERROR_ELEVATION_REQUIRED) == UV_EACCES); + ASSERT(uv_translate_sys_error(WSAEADDRINUSE) == UV_EADDRINUSE); + ASSERT(uv_translate_sys_error(ERROR_BAD_PIPE) == UV_EPIPE); #else - ASSERT_EQ(uv_translate_sys_error(EPERM), UV_EPERM); - ASSERT_EQ(uv_translate_sys_error(EPIPE), UV_EPIPE); - ASSERT_EQ(uv_translate_sys_error(EINVAL), UV_EINVAL); + ASSERT(uv_translate_sys_error(EPERM) == UV_EPERM); + ASSERT(uv_translate_sys_error(EPIPE) == UV_EPIPE); + ASSERT(uv_translate_sys_error(EINVAL) == UV_EINVAL); #endif - ASSERT_EQ(uv_translate_sys_error(UV_EINVAL), UV_EINVAL); - ASSERT_EQ(uv_translate_sys_error(UV_ERANGE), UV_ERANGE); - ASSERT_EQ(uv_translate_sys_error(UV_EACCES), UV_EACCES); - ASSERT_OK(uv_translate_sys_error(0)); + ASSERT(uv_translate_sys_error(UV_EINVAL) == UV_EINVAL); + ASSERT(uv_translate_sys_error(UV_ERANGE) == UV_ERANGE); + ASSERT(uv_translate_sys_error(UV_EACCES) == UV_EACCES); + ASSERT(uv_translate_sys_error(0) == 0); return 0; } diff --git a/test/test-fork.c b/test/test-fork.c index fe42f03..9e4684f 100644 --- a/test/test-fork.c +++ b/test/test-fork.c @@ -27,10 +27,6 @@ #include #include -#ifdef __APPLE__ -#include -#endif - #include "uv.h" #include "task.h" @@ -51,30 +47,29 @@ static char socket_cb_read_buf[1024]; static void socket_cb(uv_poll_t* poll, int status, int events) { ssize_t cnt; socket_cb_called++; - ASSERT_OK(status); + ASSERT(0 == status); printf("Socket cb got events %d\n", events); - ASSERT_EQ(UV_READABLE, (events & UV_READABLE)); + ASSERT(UV_READABLE == (events & UV_READABLE)); if (socket_cb_read_fd) { cnt = read(socket_cb_read_fd, socket_cb_read_buf, socket_cb_read_size); - ASSERT_EQ(cnt, socket_cb_read_size); + ASSERT(cnt == socket_cb_read_size); } uv_close((uv_handle_t*) poll, NULL); } static void run_timer_loop_once(void) { - uv_loop_t loop; + uv_loop_t* loop; uv_timer_t timer_handle; - ASSERT_OK(uv_loop_init(&loop)); + loop = uv_default_loop(); timer_cb_called = 0; /* Reset for the child. */ - ASSERT_OK(uv_timer_init(&loop, &timer_handle)); - ASSERT_OK(uv_timer_start(&timer_handle, timer_cb, 1, 0)); - ASSERT_OK(uv_run(&loop, UV_RUN_DEFAULT)); - ASSERT_EQ(1, timer_cb_called); - ASSERT_OK(uv_loop_close(&loop)); + ASSERT(0 == uv_timer_init(loop, &timer_handle)); + ASSERT(0 == uv_timer_start(&timer_handle, timer_cb, 1, 0)); + ASSERT(0 == uv_run(loop, UV_RUN_DEFAULT)); + ASSERT(1 == timer_cb_called); } @@ -87,10 +82,10 @@ static void assert_wait_child(pid_t child_pid) { if (waited_pid == -1) { perror("Failed to wait"); } - ASSERT_EQ(child_pid, waited_pid); + ASSERT(child_pid == waited_pid); ASSERT(WIFEXITED(child_stat)); /* Clean exit, not a signal. */ ASSERT(!WIFSIGNALED(child_stat)); - ASSERT_OK(WEXITSTATUS(child_stat)); + ASSERT(0 == WEXITSTATUS(child_stat)); } @@ -104,23 +99,19 @@ TEST_IMPL(fork_timer) { pid_t child_pid; run_timer_loop_once(); -#if defined(__APPLE__) && (TARGET_OS_TV || TARGET_OS_WATCH) - child_pid = -1; -#else child_pid = fork(); -#endif - ASSERT_NE(child_pid, -1); + ASSERT(child_pid != -1); if (child_pid != 0) { /* parent */ assert_wait_child(child_pid); } else { /* child */ - ASSERT_OK(uv_loop_fork(uv_default_loop())); + ASSERT(0 == uv_loop_fork(uv_default_loop())); run_timer_loop_once(); } - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -135,33 +126,29 @@ TEST_IMPL(fork_socketpair) { /* Prime the loop. */ run_timer_loop_once(); - ASSERT_OK(socketpair(AF_UNIX, SOCK_STREAM, 0, socket_fds)); + ASSERT(0 == socketpair(AF_UNIX, SOCK_STREAM, 0, socket_fds)); /* Create the server watcher in the parent, use it in the child. */ - ASSERT_OK(uv_poll_init(uv_default_loop(), &poll_handle, socket_fds[0])); + ASSERT(0 == uv_poll_init(uv_default_loop(), &poll_handle, socket_fds[0])); -#if defined(__APPLE__) && (TARGET_OS_TV || TARGET_OS_WATCH) - child_pid = -1; -#else child_pid = fork(); -#endif - ASSERT_NE(child_pid, -1); + ASSERT(child_pid != -1); if (child_pid != 0) { /* parent */ - ASSERT_EQ(3, send(socket_fds[1], "hi\n", 3, 0)); + ASSERT(3 == send(socket_fds[1], "hi\n", 3, 0)); assert_wait_child(child_pid); } else { /* child */ - ASSERT_OK(uv_loop_fork(uv_default_loop())); - ASSERT_OK(socket_cb_called); - ASSERT_OK(uv_poll_start(&poll_handle, UV_READABLE, socket_cb)); + ASSERT(0 == uv_loop_fork(uv_default_loop())); + ASSERT(0 == socket_cb_called); + ASSERT(0 == uv_poll_start(&poll_handle, UV_READABLE, socket_cb)); printf("Going to run the loop in the child\n"); - ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT)); - ASSERT_EQ(1, socket_cb_called); + ASSERT(0 == uv_run(uv_default_loop(), UV_RUN_DEFAULT)); + ASSERT(1 == socket_cb_called); } - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -176,60 +163,56 @@ TEST_IMPL(fork_socketpair_started) { char sync_buf[1]; uv_poll_t poll_handle; - ASSERT_OK(pipe(sync_pipe)); + ASSERT(0 == pipe(sync_pipe)); /* Prime the loop. */ run_timer_loop_once(); - ASSERT_OK(socketpair(AF_UNIX, SOCK_STREAM, 0, socket_fds)); + ASSERT(0 == socketpair(AF_UNIX, SOCK_STREAM, 0, socket_fds)); /* Create and start the server watcher in the parent, use it in the child. */ - ASSERT_OK(uv_poll_init(uv_default_loop(), &poll_handle, socket_fds[0])); - ASSERT_OK(uv_poll_start(&poll_handle, UV_READABLE, socket_cb)); + ASSERT(0 == uv_poll_init(uv_default_loop(), &poll_handle, socket_fds[0])); + ASSERT(0 == uv_poll_start(&poll_handle, UV_READABLE, socket_cb)); /* Run the loop AFTER the poll watcher is registered to make sure it gets passed to the kernel. Use NOWAIT and expect a non-zero return to prove the poll watcher is active. */ - ASSERT_EQ(1, uv_run(uv_default_loop(), UV_RUN_NOWAIT)); + ASSERT(1 == uv_run(uv_default_loop(), UV_RUN_NOWAIT)); -#if defined(__APPLE__) && (TARGET_OS_TV || TARGET_OS_WATCH) - child_pid = -1; -#else child_pid = fork(); -#endif - ASSERT_NE(child_pid, -1); + ASSERT(child_pid != -1); if (child_pid != 0) { /* parent */ - ASSERT_OK(uv_poll_stop(&poll_handle)); + ASSERT(0 == uv_poll_stop(&poll_handle)); uv_close((uv_handle_t*)&poll_handle, NULL); - ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT)); - ASSERT_OK(socket_cb_called); - ASSERT_EQ(1, write(sync_pipe[1], "1", 1)); /* alert child */ - ASSERT_EQ(3, send(socket_fds[1], "hi\n", 3, 0)); + ASSERT(0 == uv_run(uv_default_loop(), UV_RUN_DEFAULT)); + ASSERT(0 == socket_cb_called); + ASSERT(1 == write(sync_pipe[1], "1", 1)); /* alert child */ + ASSERT(3 == send(socket_fds[1], "hi\n", 3, 0)); - ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT)); - ASSERT_OK(socket_cb_called); + ASSERT(0 == uv_run(uv_default_loop(), UV_RUN_DEFAULT)); + ASSERT(0 == socket_cb_called); assert_wait_child(child_pid); } else { /* child */ printf("Child is %d\n", getpid()); - ASSERT_EQ(1, read(sync_pipe[0], sync_buf, 1)); /* wait for parent */ - ASSERT_OK(uv_loop_fork(uv_default_loop())); - ASSERT_OK(socket_cb_called); + ASSERT(1 == read(sync_pipe[0], sync_buf, 1)); /* wait for parent */ + ASSERT(0 == uv_loop_fork(uv_default_loop())); + ASSERT(0 == socket_cb_called); printf("Going to run the loop in the child\n"); socket_cb_read_fd = socket_fds[0]; socket_cb_read_size = 3; - ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT)); - ASSERT_EQ(1, socket_cb_called); + ASSERT(0 == uv_run(uv_default_loop(), UV_RUN_DEFAULT)); + ASSERT(1 == socket_cb_called); printf("Buf %s\n", socket_cb_read_buf); - ASSERT_OK(strcmp("hi\n", socket_cb_read_buf)); + ASSERT(0 == strcmp("hi\n", socket_cb_read_buf)); } - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -253,46 +236,40 @@ TEST_IMPL(fork_signal_to_child) { fork_signal_cb_called = 0; /* reset */ - ASSERT_OK(pipe(sync_pipe)); + ASSERT(0 == pipe(sync_pipe)); /* Prime the loop. */ run_timer_loop_once(); - ASSERT_OK(uv_signal_init(uv_default_loop(), &signal_handle)); - ASSERT_OK(uv_signal_start(&signal_handle, - fork_signal_to_child_cb, - SIGUSR1)); + ASSERT(0 == uv_signal_init(uv_default_loop(), &signal_handle)); + ASSERT(0 == uv_signal_start(&signal_handle, fork_signal_to_child_cb, SIGUSR1)); -#if defined(__APPLE__) && (TARGET_OS_TV || TARGET_OS_WATCH) - child_pid = -1; -#else child_pid = fork(); -#endif - ASSERT_NE(child_pid, -1); + ASSERT(child_pid != -1); if (child_pid != 0) { /* parent */ - ASSERT_EQ(1, read(sync_pipe[0], sync_buf, 1)); /* wait for child */ - ASSERT_OK(kill(child_pid, SIGUSR1)); + ASSERT(1 == read(sync_pipe[0], sync_buf, 1)); /* wait for child */ + ASSERT(0 == kill(child_pid, SIGUSR1)); /* Run the loop, make sure we don't get the signal. */ printf("Running loop in parent\n"); uv_unref((uv_handle_t*)&signal_handle); - ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_NOWAIT)); - ASSERT_OK(fork_signal_cb_called); + ASSERT(0 == uv_run(uv_default_loop(), UV_RUN_NOWAIT)); + ASSERT(0 == fork_signal_cb_called); printf("Waiting for child in parent\n"); assert_wait_child(child_pid); } else { /* child */ - ASSERT_OK(uv_loop_fork(uv_default_loop())); - ASSERT_EQ(1, write(sync_pipe[1], "1", 1)); /* alert parent */ + ASSERT(0 == uv_loop_fork(uv_default_loop())); + ASSERT(1 == write(sync_pipe[1], "1", 1)); /* alert parent */ /* Get the signal. */ - ASSERT_NE(0, uv_loop_alive(uv_default_loop())); + ASSERT(0 != uv_loop_alive(uv_default_loop())); printf("Running loop in child\n"); - ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_ONCE)); - ASSERT_EQ(SIGUSR1, fork_signal_cb_called); + ASSERT(0 == uv_run(uv_default_loop(), UV_RUN_ONCE)); + ASSERT(SIGUSR1 == fork_signal_cb_called); } - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -310,49 +287,43 @@ TEST_IMPL(fork_signal_to_child_closed) { fork_signal_cb_called = 0; /* reset */ - ASSERT_OK(pipe(sync_pipe)); - ASSERT_OK(pipe(sync_pipe2)); + ASSERT(0 == pipe(sync_pipe)); + ASSERT(0 == pipe(sync_pipe2)); /* Prime the loop. */ run_timer_loop_once(); - ASSERT_OK(uv_signal_init(uv_default_loop(), &signal_handle)); - ASSERT_OK(uv_signal_start(&signal_handle, - fork_signal_to_child_cb, - SIGUSR1)); + ASSERT(0 == uv_signal_init(uv_default_loop(), &signal_handle)); + ASSERT(0 == uv_signal_start(&signal_handle, fork_signal_to_child_cb, SIGUSR1)); -#if defined(__APPLE__) && (TARGET_OS_TV || TARGET_OS_WATCH) - child_pid = -1; -#else child_pid = fork(); -#endif - ASSERT_NE(child_pid, -1); + ASSERT(child_pid != -1); if (child_pid != 0) { /* parent */ printf("Wating on child in parent\n"); - ASSERT_EQ(1, read(sync_pipe[0], sync_buf, 1)); /* wait for child */ + ASSERT(1 == read(sync_pipe[0], sync_buf, 1)); /* wait for child */ printf("Parent killing child\n"); - ASSERT_OK(kill(child_pid, SIGUSR1)); + ASSERT(0 == kill(child_pid, SIGUSR1)); /* Run the loop, make sure we don't get the signal. */ printf("Running loop in parent\n"); uv_unref((uv_handle_t*)&signal_handle); /* so the loop can exit; we *shouldn't* get any signals */ run_timer_loop_once(); /* but while we share a pipe, we do, so have something active. */ - ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_ONCE)); + ASSERT(0 == uv_run(uv_default_loop(), UV_RUN_ONCE)); printf("Signal in parent %d\n", fork_signal_cb_called); - ASSERT_OK(fork_signal_cb_called); - ASSERT_EQ(1, write(sync_pipe2[1], "1", 1)); /* alert child */ + ASSERT(0 == fork_signal_cb_called); + ASSERT(1 == write(sync_pipe2[1], "1", 1)); /* alert child */ printf("Waiting for child in parent\n"); assert_wait_child(child_pid); } else { /* Child. Our signal handler should still be installed. */ - ASSERT_OK(uv_loop_fork(uv_default_loop())); + ASSERT(0 == uv_loop_fork(uv_default_loop())); printf("Checking loop in child\n"); - ASSERT_NE(0, uv_loop_alive(uv_default_loop())); + ASSERT(0 != uv_loop_alive(uv_default_loop())); printf("Alerting parent in child\n"); - ASSERT_EQ(1, write(sync_pipe[1], "1", 1)); /* alert parent */ + ASSERT(1 == write(sync_pipe[1], "1", 1)); /* alert parent */ /* Don't run the loop. Wait for the parent to call us */ printf("Waiting on parent in child\n"); /* Wait for parent. read may fail if the parent tripped an ASSERT @@ -360,7 +331,7 @@ TEST_IMPL(fork_signal_to_child_closed) { */ r = read(sync_pipe2[0], sync_buf, 1); ASSERT(-1 <= r && r <= 1); - ASSERT_OK(fork_signal_cb_called); + ASSERT(0 == fork_signal_cb_called); printf("Exiting child \n"); /* Note that we're deliberately not running the loop * in the child, and also not closing the loop's handles, @@ -371,48 +342,7 @@ TEST_IMPL(fork_signal_to_child_closed) { exit(0); } - MAKE_VALGRIND_HAPPY(uv_default_loop()); - return 0; -} - -static void fork_signal_cb(uv_signal_t* h, int s) { - fork_signal_cb_called = s; -} -static void empty_close_cb(uv_handle_t* h){} - -TEST_IMPL(fork_close_signal_in_child) { - uv_loop_t loop; - uv_signal_t signal_handle; - pid_t child_pid; - - ASSERT_OK(uv_loop_init(&loop)); - ASSERT_OK(uv_signal_init(&loop, &signal_handle)); - ASSERT_OK(uv_signal_start(&signal_handle, &fork_signal_cb, SIGHUP)); - - ASSERT_OK(kill(getpid(), SIGHUP)); - child_pid = fork(); - ASSERT_NE(child_pid, -1); - ASSERT_OK(fork_signal_cb_called); - - if (!child_pid) { - uv_loop_fork(&loop); - uv_close((uv_handle_t*)&signal_handle, &empty_close_cb); - uv_run(&loop, UV_RUN_DEFAULT); - /* Child doesn't receive the signal */ - ASSERT_OK(fork_signal_cb_called); - } else { - /* Parent. Runing once to receive the signal */ - uv_run(&loop, UV_RUN_ONCE); - ASSERT_EQ(SIGHUP, fork_signal_cb_called); - - /* loop should stop after closing the only handle */ - uv_close((uv_handle_t*)&signal_handle, &empty_close_cb); - ASSERT_OK(uv_run(&loop, UV_RUN_DEFAULT)); - - assert_wait_child(child_pid); - } - - MAKE_VALGRIND_HAPPY(&loop); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -423,11 +353,11 @@ static void create_file(const char* name) { uv_fs_t req; r = uv_fs_open(NULL, &req, name, O_WRONLY | O_CREAT, S_IWUSR | S_IRUSR, NULL); - ASSERT_GE(r, 0); + ASSERT(r >= 0); file = r; uv_fs_req_cleanup(&req); r = uv_fs_close(NULL, &req, file, NULL); - ASSERT_OK(r); + ASSERT(r == 0); uv_fs_req_cleanup(&req); } @@ -439,17 +369,17 @@ static void touch_file(const char* name) { uv_buf_t buf; r = uv_fs_open(NULL, &req, name, O_RDWR, 0, NULL); - ASSERT_GE(r, 0); + ASSERT(r >= 0); file = r; uv_fs_req_cleanup(&req); buf = uv_buf_init("foo", 4); r = uv_fs_write(NULL, &req, file, &buf, 1, -1, NULL); - ASSERT_GE(r, 0); + ASSERT(r >= 0); uv_fs_req_cleanup(&req); r = uv_fs_close(NULL, &req, file, NULL); - ASSERT_OK(r); + ASSERT(r == 0); uv_fs_req_cleanup(&req); } @@ -469,11 +399,11 @@ static void fs_event_cb_file_current_dir(uv_fs_event_t* handle, const char* filename, int events, int status) { - ASSERT_OK(fs_event_cb_called); + ASSERT(fs_event_cb_called == 0); ++fs_event_cb_called; - ASSERT_OK(status); + ASSERT(status == 0); #if defined(__APPLE__) || defined(__linux__) - ASSERT_OK(strcmp(filename, "watch_file")); + ASSERT(strcmp(filename, "watch_file") == 0); #else ASSERT(filename == NULL || strcmp(filename, "watch_file") == 0); #endif @@ -491,28 +421,28 @@ static void assert_watch_file_current_dir(uv_loop_t* const loop, int file_or_dir create_file("watch_file"); r = uv_fs_event_init(loop, &fs_event); - ASSERT_OK(r); + ASSERT(r == 0); /* watching a dir is the only way to get fsevents involved on apple platforms */ r = uv_fs_event_start(&fs_event, fs_event_cb_file_current_dir, file_or_dir == 1 ? "." : "watch_file", 0); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_timer_init(loop, &timer); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_timer_start(&timer, timer_cb_touch, 100, 0); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_OK(timer_cb_touch_called); - ASSERT_OK(fs_event_cb_called); + ASSERT(timer_cb_touch_called == 0); + ASSERT(fs_event_cb_called == 0); uv_run(loop, UV_RUN_DEFAULT); - ASSERT_EQ(1, timer_cb_touch_called); - ASSERT_EQ(1, fs_event_cb_called); + ASSERT(timer_cb_touch_called == 1); + ASSERT(fs_event_cb_called == 1); /* Cleanup */ remove("watch_file"); @@ -532,12 +462,8 @@ static int _do_fork_fs_events_child(int file_or_dir) { /* Watch in the parent, prime the loop and/or threads. */ assert_watch_file_current_dir(uv_default_loop(), file_or_dir); -#if defined(__APPLE__) && (TARGET_OS_TV || TARGET_OS_WATCH) - child_pid = -1; -#else child_pid = fork(); -#endif - ASSERT_NE(child_pid, -1); + ASSERT(child_pid != -1); if (child_pid != 0) { /* parent */ @@ -553,10 +479,10 @@ static int _do_fork_fs_events_child(int file_or_dir) { uv_loop_init(&loop); printf("Child first watch\n"); assert_watch_file_current_dir(&loop, file_or_dir); - ASSERT_OK(uv_loop_close(&loop)); + ASSERT(0 == uv_loop_close(&loop)); printf("Child second watch default loop\n"); /* Ee can watch in the default loop. */ - ASSERT_OK(uv_loop_fork(uv_default_loop())); + ASSERT(0 == uv_loop_fork(uv_default_loop())); /* On some platforms (OS X), if we don't update the time now, * the timer cb fires before the event loop enters uv__io_poll, * instead of after, meaning we don't see the change! This may be @@ -569,12 +495,12 @@ static int _do_fork_fs_events_child(int file_or_dir) { especially important on Apple platforms where if we're not careful trying to touch the CFRunLoop, even just to shut it down, that we allocated in the FS_TEST_DIR case would crash. */ - ASSERT_OK(uv_loop_close(uv_default_loop())); + ASSERT(0 == uv_loop_close(uv_default_loop())); printf("Exiting child \n"); } - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -632,40 +558,36 @@ TEST_IMPL(fork_fs_events_file_parent_child) { create_file("watch_file"); r = uv_fs_event_init(loop, &fs_event); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_fs_event_start(&fs_event, fs_event_cb_file_current_dir, "watch_file", 0); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_timer_init(loop, &timer); - ASSERT_OK(r); + ASSERT(r == 0); -#if defined(__APPLE__) && (TARGET_OS_TV || TARGET_OS_WATCH) - child_pid = -1; -#else child_pid = fork(); -#endif - ASSERT_NE(child_pid, -1); + ASSERT(child_pid != -1); if (child_pid != 0) { /* parent */ assert_wait_child(child_pid); } else { /* child */ printf("Running child\n"); - ASSERT_OK(uv_loop_fork(loop)); + ASSERT(0 == uv_loop_fork(loop)); r = uv_timer_start(&timer, timer_cb_touch, 100, 0); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_OK(timer_cb_touch_called); - ASSERT_OK(fs_event_cb_called); + ASSERT(timer_cb_touch_called == 0); + ASSERT(fs_event_cb_called == 0); printf("Running loop in child \n"); uv_run(loop, UV_RUN_DEFAULT); - ASSERT_EQ(1, timer_cb_touch_called); - ASSERT_EQ(1, fs_event_cb_called); + ASSERT(timer_cb_touch_called == 1); + ASSERT(fs_event_cb_called == 1); /* Cleanup */ remove("watch_file"); @@ -675,7 +597,7 @@ TEST_IMPL(fork_fs_events_file_parent_child) { } - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; #endif } @@ -691,7 +613,7 @@ static void work_cb(uv_work_t* req) { static void after_work_cb(uv_work_t* req, int status) { - ASSERT_OK(status); + ASSERT(status == 0); after_work_cb_count++; } @@ -700,16 +622,16 @@ static void assert_run_work(uv_loop_t* const loop) { uv_work_t work_req; int r; - ASSERT_OK(work_cb_count); - ASSERT_OK(after_work_cb_count); + ASSERT(work_cb_count == 0); + ASSERT(after_work_cb_count == 0); printf("Queue in %d\n", getpid()); r = uv_queue_work(loop, &work_req, work_cb, after_work_cb); - ASSERT_OK(r); + ASSERT(r == 0); printf("Running in %d\n", getpid()); uv_run(loop, UV_RUN_DEFAULT); - ASSERT_EQ(1, work_cb_count); - ASSERT_EQ(1, after_work_cb_count); + ASSERT(work_cb_count == 1); + ASSERT(after_work_cb_count == 1); /* cleanup */ work_cb_count = 0; @@ -724,19 +646,11 @@ TEST_IMPL(fork_threadpool_queue_work_simple) { pid_t child_pid; uv_loop_t loop; -#ifdef __TSAN__ - RETURN_SKIP("ThreadSanitizer doesn't support multi-threaded fork"); -#endif - /* Prime the pool and default loop. */ assert_run_work(uv_default_loop()); -#if defined(__APPLE__) && (TARGET_OS_TV || TARGET_OS_WATCH) - child_pid = -1; -#else child_pid = fork(); -#endif - ASSERT_NE(child_pid, -1); + ASSERT(child_pid != -1); if (child_pid != 0) { /* Parent. We can still run work. */ @@ -751,13 +665,13 @@ TEST_IMPL(fork_threadpool_queue_work_simple) { uv_loop_close(&loop); printf("Child second watch default loop\n"); /* We can work in the default loop. */ - ASSERT_OK(uv_loop_fork(uv_default_loop())); + ASSERT(0 == uv_loop_fork(uv_default_loop())); assert_run_work(uv_default_loop()); printf("Exiting child \n"); } - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } #endif /* !__MVS__ */ diff --git a/test/test-fs-copyfile.c b/test/test-fs-copyfile.c index 3aacf12..9ffa5b4 100644 --- a/test/test-fs-copyfile.c +++ b/test/test-fs-copyfile.c @@ -48,19 +48,19 @@ static void handle_result(uv_fs_t* req) { uint64_t mode; int r; - ASSERT_EQ(req->fs_type, UV_FS_COPYFILE); - ASSERT_OK(req->result); + ASSERT(req->fs_type == UV_FS_COPYFILE); + ASSERT(req->result == 0); /* Verify that the file size and mode are the same. */ r = uv_fs_stat(NULL, &stat_req, req->path, NULL); - ASSERT_OK(r); + ASSERT(r == 0); size = stat_req.statbuf.st_size; mode = stat_req.statbuf.st_mode; uv_fs_req_cleanup(&stat_req); r = uv_fs_stat(NULL, &stat_req, dst, NULL); - ASSERT_OK(r); - ASSERT_EQ(stat_req.statbuf.st_size, size); - ASSERT_EQ(stat_req.statbuf.st_mode, mode); + ASSERT(r == 0); + ASSERT(stat_req.statbuf.st_size == size); + ASSERT(stat_req.statbuf.st_mode == mode); uv_fs_req_cleanup(&stat_req); uv_fs_req_cleanup(req); result_check_count++; @@ -74,11 +74,10 @@ static void touch_file(const char* name, unsigned int size) { int r; unsigned int i; - r = uv_fs_open(NULL, &req, name, - UV_FS_O_WRONLY | UV_FS_O_CREAT | UV_FS_O_TRUNC, + r = uv_fs_open(NULL, &req, name, O_WRONLY | O_CREAT | O_TRUNC, S_IWUSR | S_IRUSR, NULL); uv_fs_req_cleanup(&req); - ASSERT_GE(r, 0); + ASSERT(r >= 0); file = r; buf = uv_buf_init("a", 1); @@ -87,12 +86,12 @@ static void touch_file(const char* name, unsigned int size) { for (i = 0; i < size; i++) { r = uv_fs_write(NULL, &req, file, &buf, 1, i, NULL); uv_fs_req_cleanup(&req); - ASSERT_GE(r, 0); + ASSERT(r >= 0); } r = uv_fs_close(NULL, &req, file, NULL); uv_fs_req_cleanup(&req); - ASSERT_OK(r); + ASSERT(r == 0); } @@ -106,121 +105,99 @@ TEST_IMPL(fs_copyfile) { /* Fails with EINVAL if bad flags are passed. */ r = uv_fs_copyfile(NULL, &req, src, dst, -1, NULL); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); uv_fs_req_cleanup(&req); /* Fails with ENOENT if source does not exist. */ unlink(src); unlink(dst); r = uv_fs_copyfile(NULL, &req, src, dst, 0, NULL); - ASSERT_EQ(req.result, UV_ENOENT); - ASSERT_EQ(r, UV_ENOENT); + ASSERT(req.result == UV_ENOENT); + ASSERT(r == UV_ENOENT); uv_fs_req_cleanup(&req); /* The destination should not exist. */ r = uv_fs_stat(NULL, &req, dst, NULL); - ASSERT(r); + ASSERT(r != 0); uv_fs_req_cleanup(&req); /* Succeeds if src and dst files are identical. */ touch_file(src, 12); r = uv_fs_copyfile(NULL, &req, src, src, 0, NULL); - ASSERT_OK(r); + ASSERT(r == 0); uv_fs_req_cleanup(&req); /* Verify that the src file did not get truncated. */ r = uv_fs_stat(NULL, &req, src, NULL); - ASSERT_OK(r); - ASSERT_EQ(12, req.statbuf.st_size); + ASSERT_EQ(r, 0); + ASSERT_EQ(req.statbuf.st_size, 12); uv_fs_req_cleanup(&req); unlink(src); /* Copies file synchronously. Creates new file. */ unlink(dst); r = uv_fs_copyfile(NULL, &req, fixture, dst, 0, NULL); - ASSERT_OK(r); + ASSERT(r == 0); handle_result(&req); /* Copies a file of size zero. */ unlink(dst); touch_file(src, 0); r = uv_fs_copyfile(NULL, &req, src, dst, 0, NULL); - ASSERT_OK(r); + ASSERT(r == 0); handle_result(&req); /* Copies file synchronously. Overwrites existing file. */ r = uv_fs_copyfile(NULL, &req, fixture, dst, 0, NULL); - ASSERT_OK(r); + ASSERT(r == 0); handle_result(&req); /* Fails to overwrites existing file. */ - ASSERT_OK(uv_fs_chmod(NULL, &req, dst, 0644, NULL)); - uv_fs_req_cleanup(&req); r = uv_fs_copyfile(NULL, &req, fixture, dst, UV_FS_COPYFILE_EXCL, NULL); - ASSERT_EQ(r, UV_EEXIST); + ASSERT(r == UV_EEXIST); uv_fs_req_cleanup(&req); /* Truncates when an existing destination is larger than the source file. */ - ASSERT_OK(uv_fs_chmod(NULL, &req, dst, 0644, NULL)); - uv_fs_req_cleanup(&req); touch_file(src, 1); r = uv_fs_copyfile(NULL, &req, src, dst, 0, NULL); - ASSERT_OK(r); + ASSERT(r == 0); handle_result(&req); /* Copies a larger file. */ unlink(dst); touch_file(src, 4096 * 2); r = uv_fs_copyfile(NULL, &req, src, dst, 0, NULL); - ASSERT_OK(r); + ASSERT(r == 0); handle_result(&req); unlink(src); /* Copies file asynchronously */ unlink(dst); r = uv_fs_copyfile(loop, &req, fixture, dst, 0, handle_result); - ASSERT_OK(r); - ASSERT_EQ(5, result_check_count); + ASSERT(r == 0); + ASSERT(result_check_count == 5); uv_run(loop, UV_RUN_DEFAULT); - ASSERT_EQ(6, result_check_count); - /* Ensure file is user-writable (not copied from src). */ - ASSERT_OK(uv_fs_chmod(NULL, &req, dst, 0644, NULL)); - uv_fs_req_cleanup(&req); + ASSERT(result_check_count == 6); /* If the flags are invalid, the loop should not be kept open */ unlink(dst); r = uv_fs_copyfile(loop, &req, fixture, dst, -1, fail_cb); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); uv_run(loop, UV_RUN_DEFAULT); /* Copies file using UV_FS_COPYFILE_FICLONE. */ unlink(dst); r = uv_fs_copyfile(NULL, &req, fixture, dst, UV_FS_COPYFILE_FICLONE, NULL); - ASSERT_OK(r); + ASSERT(r == 0); handle_result(&req); /* Copies file using UV_FS_COPYFILE_FICLONE_FORCE. */ unlink(dst); r = uv_fs_copyfile(NULL, &req, fixture, dst, UV_FS_COPYFILE_FICLONE_FORCE, NULL); - ASSERT_LE(r, 0); + ASSERT(r <= 0); if (r == 0) handle_result(&req); -#ifndef _WIN32 - /* Copying respects permissions/mode. */ - unlink(dst); - touch_file(dst, 0); - chmod(dst, S_IRUSR|S_IRGRP|S_IROTH); /* Sets file mode to 444 (read-only). */ - r = uv_fs_copyfile(NULL, &req, fixture, dst, 0, NULL); - /* On IBMi PASE, qsecofr users can overwrite read-only files */ -# ifndef __PASE__ - ASSERT_EQ(req.result, UV_EACCES); - ASSERT_EQ(r, UV_EACCES); -# endif - uv_fs_req_cleanup(&req); -#endif - unlink(dst); /* Cleanup */ - MAKE_VALGRIND_HAPPY(loop); return 0; } diff --git a/test/test-fs-event.c b/test/test-fs-event.c index 0ef5118..a08bfb9 100644 --- a/test/test-fs-event.c +++ b/test/test-fs-event.c @@ -33,12 +33,19 @@ # if defined(__APPLE__) || \ defined(__DragonFly__) || \ defined(__FreeBSD__) || \ + defined(__FreeBSD_kernel__) || \ defined(__OpenBSD__) || \ defined(__NetBSD__) # define HAVE_KQUEUE 1 # endif #endif +#if defined(__arm__)/* Increase the timeout so the test passes on arm CI bots */ +# define CREATE_TIMEOUT 100 +#else +# define CREATE_TIMEOUT 1 +#endif + static uv_fs_event_t fs_event; static const char file_prefix[] = "fsevent-"; static const int fs_event_file_count = 16; @@ -80,14 +87,12 @@ static void create_file(const char* name) { uv_file file; uv_fs_t req; - r = uv_fs_open(NULL, &req, name, UV_FS_O_WRONLY | UV_FS_O_CREAT, - S_IWUSR | S_IRUSR, - NULL); - ASSERT_GE(r, 0); + r = uv_fs_open(NULL, &req, name, O_WRONLY | O_CREAT, S_IWUSR | S_IRUSR, NULL); + ASSERT(r >= 0); file = r; uv_fs_req_cleanup(&req); r = uv_fs_close(NULL, &req, file, NULL); - ASSERT_OK(r); + ASSERT(r == 0); uv_fs_req_cleanup(&req); } @@ -97,18 +102,18 @@ static void touch_file(const char* name) { uv_fs_t req; uv_buf_t buf; - r = uv_fs_open(NULL, &req, name, UV_FS_O_RDWR, 0, NULL); - ASSERT_GE(r, 0); + r = uv_fs_open(NULL, &req, name, O_RDWR, 0, NULL); + ASSERT(r >= 0); file = r; uv_fs_req_cleanup(&req); buf = uv_buf_init("foo", 4); r = uv_fs_write(NULL, &req, file, &buf, 1, -1, NULL); - ASSERT_GE(r, 0); + ASSERT(r >= 0); uv_fs_req_cleanup(&req); r = uv_fs_close(NULL, &req, file, NULL); - ASSERT_OK(r); + ASSERT(r == 0); uv_fs_req_cleanup(&req); } @@ -127,15 +132,15 @@ static void fail_cb(uv_fs_event_t* handle, static void fs_event_cb_dir(uv_fs_event_t* handle, const char* filename, int events, int status) { ++fs_event_cb_called; - ASSERT_PTR_EQ(handle, &fs_event); - ASSERT_OK(status); - ASSERT_EQ(events, UV_CHANGE); + ASSERT(handle == &fs_event); + ASSERT(status == 0); + ASSERT(events == UV_CHANGE); #if defined(__APPLE__) || defined(_WIN32) || defined(__linux__) - ASSERT_OK(strcmp(filename, "file1")); + ASSERT(strcmp(filename, "file1") == 0); #else ASSERT(filename == NULL || strcmp(filename, "file1") == 0); #endif - ASSERT_OK(uv_fs_event_stop(handle)); + ASSERT(0 == uv_fs_event_stop(handle)); uv_close((uv_handle_t*)handle, close_cb); } @@ -150,7 +155,7 @@ static const char* fs_event_get_filename(int i) { static void fs_event_create_files(uv_timer_t* handle) { /* Make sure we're not attempting to create files we do not intend */ - ASSERT_LT(fs_event_created, fs_event_file_count); + ASSERT(fs_event_created < fs_event_file_count); /* Create the file */ create_file(fs_event_get_filename(fs_event_created)); @@ -158,7 +163,10 @@ static void fs_event_create_files(uv_timer_t* handle) { if (++fs_event_created < fs_event_file_count) { /* Create another file on a different event loop tick. We do it this way * to avoid fs events coalescing into one fs event. */ - ASSERT_OK(uv_timer_start(&timer, fs_event_create_files, 100, 0)); + ASSERT(0 == uv_timer_start(&timer, + fs_event_create_files, + CREATE_TIMEOUT, + 0)); } } @@ -172,19 +180,19 @@ static void fs_event_unlink_files(uv_timer_t* handle) { for (i = 0; i < 16; i++) { r = remove(fs_event_get_filename(i)); if (handle != NULL) - ASSERT_OK(r); + ASSERT(r == 0); } } else { /* Make sure we're not attempting to remove files we do not intend */ - ASSERT_LT(fs_event_removed, fs_event_file_count); + ASSERT(fs_event_removed < fs_event_file_count); /* Remove the file */ - ASSERT_OK(remove(fs_event_get_filename(fs_event_removed))); + ASSERT(0 == remove(fs_event_get_filename(fs_event_removed))); if (++fs_event_removed < fs_event_file_count) { /* Remove another file on a different event loop tick. We do it this way * to avoid fs events coalescing into one fs event. */ - ASSERT_OK(uv_timer_start(&timer, fs_event_unlink_files, 1, 0)); + ASSERT(0 == uv_timer_start(&timer, fs_event_unlink_files, 1, 0)); } } } @@ -194,19 +202,19 @@ static void fs_event_cb_dir_multi_file(uv_fs_event_t* handle, int events, int status) { fs_event_cb_called++; - ASSERT_PTR_EQ(handle, &fs_event); - ASSERT_OK(status); + ASSERT(handle == &fs_event); + ASSERT(status == 0); ASSERT(events == UV_CHANGE || events == UV_RENAME); #if defined(__APPLE__) || defined(_WIN32) || defined(__linux__) - ASSERT_OK(strncmp(filename, file_prefix, sizeof(file_prefix) - 1)); + ASSERT(strncmp(filename, file_prefix, sizeof(file_prefix) - 1) == 0); #else - ASSERT_NE(filename == NULL || - strncmp(filename, file_prefix, sizeof(file_prefix) - 1) == 0, 0); + ASSERT(filename == NULL || + strncmp(filename, file_prefix, sizeof(file_prefix) - 1) == 0); #endif if (fs_event_created + fs_event_removed == fs_event_file_count) { /* Once we've processed all create events, delete all files */ - ASSERT_OK(uv_timer_start(&timer, fs_event_unlink_files, 1, 0)); + ASSERT(0 == uv_timer_start(&timer, fs_event_unlink_files, 1, 0)); } else if (fs_event_cb_called == 2 * fs_event_file_count) { /* Once we've processed all create and delete events, stop watching */ uv_close((uv_handle_t*) &timer, close_cb); @@ -226,7 +234,7 @@ static const char* fs_event_get_filename_in_subdir(int i) { static void fs_event_create_files_in_subdir(uv_timer_t* handle) { /* Make sure we're not attempting to create files we do not intend */ - ASSERT_LT(fs_event_created, fs_event_file_count); + ASSERT(fs_event_created < fs_event_file_count); /* Create the file */ create_file(fs_event_get_filename_in_subdir(fs_event_created)); @@ -234,7 +242,7 @@ static void fs_event_create_files_in_subdir(uv_timer_t* handle) { if (++fs_event_created < fs_event_file_count) { /* Create another file on a different event loop tick. We do it this way * to avoid fs events coalescing into one fs event. */ - ASSERT_OK(uv_timer_start(&timer, fs_event_create_files_in_subdir, 100, 0)); + ASSERT(0 == uv_timer_start(&timer, fs_event_create_files_in_subdir, 1, 0)); } } @@ -248,22 +256,19 @@ static void fs_event_unlink_files_in_subdir(uv_timer_t* handle) { for (i = 0; i < 16; i++) { r = remove(fs_event_get_filename_in_subdir(i)); if (handle != NULL) - ASSERT_OK(r); + ASSERT(r == 0); } } else { /* Make sure we're not attempting to remove files we do not intend */ - ASSERT_LT(fs_event_removed, fs_event_file_count); + ASSERT(fs_event_removed < fs_event_file_count); /* Remove the file */ - ASSERT_OK(remove(fs_event_get_filename_in_subdir(fs_event_removed))); + ASSERT(0 == remove(fs_event_get_filename_in_subdir(fs_event_removed))); if (++fs_event_removed < fs_event_file_count) { /* Remove another file on a different event loop tick. We do it this way * to avoid fs events coalescing into one fs event. */ - ASSERT_OK(uv_timer_start(&timer, - fs_event_unlink_files_in_subdir, - 1, - 0)); + ASSERT(0 == uv_timer_start(&timer, fs_event_unlink_files_in_subdir, 1, 0)); } } } @@ -287,30 +292,27 @@ static void fs_event_cb_dir_multi_file_in_subdir(uv_fs_event_t* handle, return; fs_multievent_cb_called++; - ASSERT_PTR_EQ(handle, &fs_event); - ASSERT_OK(status); + ASSERT(handle == &fs_event); + ASSERT(status == 0); ASSERT(events == UV_CHANGE || events == UV_RENAME); #if defined(__APPLE__) || defined(_WIN32) || defined(__linux__) - ASSERT_OK(strncmp(filename, - file_prefix_in_subdir, - sizeof(file_prefix_in_subdir) - 1)); + ASSERT(strncmp(filename, + file_prefix_in_subdir, + sizeof(file_prefix_in_subdir) - 1) == 0); #else - ASSERT_NE(filename == NULL || - strncmp(filename, - file_prefix_in_subdir, - sizeof(file_prefix_in_subdir) - 1) == 0, 0); + ASSERT(filename == NULL || + strncmp(filename, + file_prefix_in_subdir, + sizeof(file_prefix_in_subdir) - 1) == 0); #endif if (fs_event_created == fs_event_file_count && fs_multievent_cb_called == fs_event_created) { /* Once we've processed all create events, delete all files */ - ASSERT_OK(uv_timer_start(&timer, - fs_event_unlink_files_in_subdir, - 1, - 0)); + ASSERT(0 == uv_timer_start(&timer, fs_event_unlink_files_in_subdir, 1, 0)); } else if (fs_multievent_cb_called == 2 * fs_event_file_count) { /* Once we've processed all create and delete events, stop watching */ - ASSERT_EQ(fs_event_removed, fs_event_file_count); + ASSERT(fs_event_removed == fs_event_file_count); uv_close((uv_handle_t*) &timer, close_cb); uv_close((uv_handle_t*) handle, close_cb); } @@ -320,15 +322,15 @@ static void fs_event_cb_dir_multi_file_in_subdir(uv_fs_event_t* handle, static void fs_event_cb_file(uv_fs_event_t* handle, const char* filename, int events, int status) { ++fs_event_cb_called; - ASSERT_PTR_EQ(handle, &fs_event); - ASSERT_OK(status); - ASSERT_EQ(events, UV_CHANGE); + ASSERT(handle == &fs_event); + ASSERT(status == 0); + ASSERT(events == UV_CHANGE); #if defined(__APPLE__) || defined(_WIN32) || defined(__linux__) - ASSERT_OK(strcmp(filename, "file2")); + ASSERT(strcmp(filename, "file2") == 0); #else ASSERT(filename == NULL || strcmp(filename, "file2") == 0); #endif - ASSERT_OK(uv_fs_event_stop(handle)); + ASSERT(0 == uv_fs_event_stop(handle)); uv_close((uv_handle_t*)handle, close_cb); } @@ -336,11 +338,11 @@ static void fs_event_cb_file_current_dir(uv_fs_event_t* handle, const char* filename, int events, int status) { ++fs_event_cb_called; - ASSERT_PTR_EQ(handle, &fs_event); - ASSERT_OK(status); - ASSERT_EQ(events, UV_CHANGE); + ASSERT(handle == &fs_event); + ASSERT(status == 0); + ASSERT(events == UV_CHANGE); #if defined(__APPLE__) || defined(_WIN32) || defined(__linux__) - ASSERT_OK(strcmp(filename, "watch_file")); + ASSERT(strcmp(filename, "watch_file") == 0); #else ASSERT(filename == NULL || strcmp(filename, "watch_file") == 0); #endif @@ -373,7 +375,7 @@ static void timer_cb_exact(uv_timer_t* handle) { } else { uv_close((uv_handle_t*)handle, NULL); r = uv_fs_event_stop(&fs_event); - ASSERT_OK(r); + ASSERT(r == 0); uv_close((uv_handle_t*) &fs_event, NULL); } @@ -391,9 +393,9 @@ static void fs_event_cb_close(uv_fs_event_t* handle, const char* filename, int events, int status) { - ASSERT_OK(status); + ASSERT(status == 0); - ASSERT_LT(fs_event_cb_called, 3); + ASSERT(fs_event_cb_called < 3); ++fs_event_cb_called; if (fs_event_cb_called == 3) { @@ -407,8 +409,6 @@ TEST_IMPL(fs_event_watch_dir) { RETURN_SKIP(NO_FS_EVENTS); #elif defined(__MVS__) RETURN_SKIP("Directory watching not supported on this platform."); -#elif defined(__APPLE__) && defined(__TSAN__) - RETURN_SKIP("Times out under TSAN."); #endif uv_loop_t* loop = uv_default_loop(); @@ -422,18 +422,18 @@ TEST_IMPL(fs_event_watch_dir) { create_dir("watch_dir"); r = uv_fs_event_init(loop, &fs_event); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_fs_event_start(&fs_event, fs_event_cb_dir_multi_file, "watch_dir", 0); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_timer_init(loop, &timer); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_timer_start(&timer, fs_event_create_files, 100, 0); - ASSERT_OK(r); + ASSERT(r == 0); uv_run(loop, UV_RUN_DEFAULT); - ASSERT_EQ(fs_event_cb_called, fs_event_created + fs_event_removed); - ASSERT_EQ(2, close_cb_called); + ASSERT(fs_event_cb_called == fs_event_created + fs_event_removed); + ASSERT(close_cb_called == 2); /* Cleanup */ fs_event_unlink_files(NULL); @@ -441,15 +441,13 @@ TEST_IMPL(fs_event_watch_dir) { remove("watch_dir/file1"); remove("watch_dir/"); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } TEST_IMPL(fs_event_watch_dir_recursive) { -#if defined(__APPLE__) && defined(__TSAN__) - RETURN_SKIP("Times out under TSAN."); -#elif defined(__APPLE__) || defined(_WIN32) +#if defined(__APPLE__) || defined(_WIN32) uv_loop_t* loop; int r; uv_fs_event_t fs_event_root; @@ -465,27 +463,27 @@ TEST_IMPL(fs_event_watch_dir_recursive) { create_dir("watch_dir/subdir"); r = uv_fs_event_init(loop, &fs_event); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_fs_event_start(&fs_event, fs_event_cb_dir_multi_file_in_subdir, "watch_dir", UV_FS_EVENT_RECURSIVE); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_timer_init(loop, &timer); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_timer_start(&timer, fs_event_create_files_in_subdir, 100, 0); - ASSERT_OK(r); + ASSERT(r == 0); #ifndef _WIN32 /* Also try to watch the root directory. * This will be noisier, so we're just checking for any couple events to happen. */ r = uv_fs_event_init(loop, &fs_event_root); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_fs_event_start(&fs_event_root, fs_event_cb_close, "/", UV_FS_EVENT_RECURSIVE); - ASSERT_OK(r); + ASSERT(r == 0); #else fs_event_cb_called += 3; close_cb_called += 1; @@ -494,9 +492,9 @@ TEST_IMPL(fs_event_watch_dir_recursive) { uv_run(loop, UV_RUN_DEFAULT); - ASSERT_EQ(fs_multievent_cb_called, fs_event_created + fs_event_removed); - ASSERT_EQ(3, fs_event_cb_called); - ASSERT_EQ(3, close_cb_called); + ASSERT(fs_multievent_cb_called == fs_event_created + fs_event_removed); + ASSERT(fs_event_cb_called == 3); + ASSERT(close_cb_called == 3); /* Cleanup */ fs_event_unlink_files_in_subdir(NULL); @@ -505,7 +503,7 @@ TEST_IMPL(fs_event_watch_dir_recursive) { remove("watch_dir/subdir"); remove("watch_dir/"); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; #else RETURN_SKIP("Recursive directory watching not supported on this platform."); @@ -533,26 +531,26 @@ TEST_IMPL(fs_event_watch_dir_short_path) { has_shortnames = uv_fs_stat(NULL, &req, "watch_~1", NULL) != UV_ENOENT; if (has_shortnames) { r = uv_fs_event_init(loop, &fs_event); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_fs_event_start(&fs_event, fs_event_cb_dir, "watch_~1", 0); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_timer_init(loop, &timer); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_timer_start(&timer, timer_cb_file, 100, 0); - ASSERT_OK(r); + ASSERT(r == 0); uv_run(loop, UV_RUN_DEFAULT); - ASSERT_EQ(1, fs_event_cb_called); - ASSERT_EQ(1, timer_cb_called); - ASSERT_EQ(1, close_cb_called); + ASSERT(fs_event_cb_called == 1); + ASSERT(timer_cb_called == 1); + ASSERT(close_cb_called == 1); } /* Cleanup */ remove("watch_dir/file1"); remove("watch_dir/"); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); if (!has_shortnames) RETURN_SKIP("Was not able to address files with 8.3 short name."); @@ -579,26 +577,26 @@ TEST_IMPL(fs_event_watch_file) { create_file("watch_dir/file2"); r = uv_fs_event_init(loop, &fs_event); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_fs_event_start(&fs_event, fs_event_cb_file, "watch_dir/file2", 0); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_timer_init(loop, &timer); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_timer_start(&timer, timer_cb_file, 100, 100); - ASSERT_OK(r); + ASSERT(r == 0); uv_run(loop, UV_RUN_DEFAULT); - ASSERT_EQ(1, fs_event_cb_called); - ASSERT_EQ(2, timer_cb_called); - ASSERT_EQ(2, close_cb_called); + ASSERT(fs_event_cb_called == 1); + ASSERT(timer_cb_called == 2); + ASSERT(close_cb_called == 2); /* Cleanup */ remove("watch_dir/file2"); remove("watch_dir/file1"); remove("watch_dir/"); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -625,7 +623,7 @@ TEST_IMPL(fs_event_watch_file_exact_path) { create_file("watch_dir/file.js"); create_file("watch_dir/file.jsx"); #if defined(__APPLE__) && !defined(MAC_OS_X_VERSION_10_12) - /* Empirically, FSEvents seems to (reliably) report the preceding + /* Empirically, FSEvents seems to (reliably) report the preceeding * create_file events prior to macOS 10.11.6 in the subsequent fs_watch * creation, but that behavior hasn't been observed to occur on newer * versions. Give a long delay here to let the system settle before running @@ -635,23 +633,23 @@ TEST_IMPL(fs_event_watch_file_exact_path) { #endif r = uv_fs_event_init(loop, &fs_event); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_fs_event_start(&fs_event, fs_event_fail, "watch_dir/file.jsx", 0); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_timer_init(loop, &timer); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_timer_start(&timer, timer_cb_exact, 100, 100); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_run(loop, UV_RUN_DEFAULT); - ASSERT_OK(r); - ASSERT_EQ(2, timer_cb_exact_called); + ASSERT(r == 0); + ASSERT(timer_cb_exact_called == 2); /* Cleanup */ remove("watch_dir/file.js"); remove("watch_dir/file.jsx"); remove("watch_dir/"); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -667,15 +665,15 @@ TEST_IMPL(fs_event_watch_file_twice) { loop = uv_default_loop(); timer.data = watchers; - ASSERT_OK(uv_fs_event_init(loop, watchers + 0)); - ASSERT_OK(uv_fs_event_start(watchers + 0, fail_cb, path, 0)); - ASSERT_OK(uv_fs_event_init(loop, watchers + 1)); - ASSERT_OK(uv_fs_event_start(watchers + 1, fail_cb, path, 0)); - ASSERT_OK(uv_timer_init(loop, &timer)); - ASSERT_OK(uv_timer_start(&timer, timer_cb_watch_twice, 10, 0)); - ASSERT_OK(uv_run(loop, UV_RUN_DEFAULT)); + ASSERT(0 == uv_fs_event_init(loop, watchers + 0)); + ASSERT(0 == uv_fs_event_start(watchers + 0, fail_cb, path, 0)); + ASSERT(0 == uv_fs_event_init(loop, watchers + 1)); + ASSERT(0 == uv_fs_event_start(watchers + 1, fail_cb, path, 0)); + ASSERT(0 == uv_timer_init(loop, &timer)); + ASSERT(0 == uv_timer_start(&timer, timer_cb_watch_twice, 10, 0)); + ASSERT(0 == uv_run(loop, UV_RUN_DEFAULT)); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -693,7 +691,7 @@ TEST_IMPL(fs_event_watch_file_current_dir) { remove("watch_file"); create_file("watch_file"); #if defined(__APPLE__) && !defined(MAC_OS_X_VERSION_10_12) - /* Empirically, kevent seems to (sometimes) report the preceding + /* Empirically, kevent seems to (sometimes) report the preceeding * create_file events prior to macOS 10.11.6 in the subsequent fs_event_start * So let the system settle before running the test. */ uv_sleep(1100); @@ -701,36 +699,36 @@ TEST_IMPL(fs_event_watch_file_current_dir) { #endif r = uv_fs_event_init(loop, &fs_event); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_fs_event_start(&fs_event, fs_event_cb_file_current_dir, "watch_file", 0); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_timer_init(loop, &timer); - ASSERT_OK(r); + ASSERT(r == 0); timer.data = "watch_file"; r = uv_timer_start(&timer, timer_cb_touch, 1100, 0); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_OK(timer_cb_touch_called); - ASSERT_OK(fs_event_cb_called); - ASSERT_OK(close_cb_called); + ASSERT(timer_cb_touch_called == 0); + ASSERT(fs_event_cb_called == 0); + ASSERT(close_cb_called == 0); uv_run(loop, UV_RUN_DEFAULT); - ASSERT_EQ(1, timer_cb_touch_called); + ASSERT(timer_cb_touch_called == 1); /* FSEvents on macOS sometimes sends one change event, sometimes two. */ ASSERT_NE(0, fs_event_cb_called); - ASSERT_EQ(1, close_cb_called); + ASSERT(close_cb_called == 1); /* Cleanup */ remove("watch_file"); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -748,15 +746,15 @@ TEST_IMPL(fs_event_watch_file_root_dir) { loop = uv_default_loop(); r = uv_fs_event_init(loop, &fs_event); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_fs_event_start(&fs_event, fail_cb, path, 0); if (r == UV_ENOENT) RETURN_SKIP("bootsect.bak doesn't exist in system root.\n"); - ASSERT_OK(r); + ASSERT(r == 0); uv_close((uv_handle_t*) &fs_event, NULL); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } #endif @@ -776,26 +774,26 @@ TEST_IMPL(fs_event_no_callback_after_close) { create_file("watch_dir/file1"); r = uv_fs_event_init(loop, &fs_event); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_fs_event_start(&fs_event, fs_event_cb_file, "watch_dir/file1", 0); - ASSERT_OK(r); + ASSERT(r == 0); uv_close((uv_handle_t*)&fs_event, close_cb); touch_file("watch_dir/file1"); uv_run(loop, UV_RUN_DEFAULT); - ASSERT_OK(fs_event_cb_called); - ASSERT_EQ(1, close_cb_called); + ASSERT(fs_event_cb_called == 0); + ASSERT(close_cb_called == 1); /* Cleanup */ remove("watch_dir/file1"); remove("watch_dir/"); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -814,25 +812,25 @@ TEST_IMPL(fs_event_no_callback_on_close) { create_file("watch_dir/file1"); r = uv_fs_event_init(loop, &fs_event); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_fs_event_start(&fs_event, fs_event_cb_file, "watch_dir/file1", 0); - ASSERT_OK(r); + ASSERT(r == 0); uv_close((uv_handle_t*)&fs_event, close_cb); uv_run(loop, UV_RUN_DEFAULT); - ASSERT_OK(fs_event_cb_called); - ASSERT_EQ(1, close_cb_called); + ASSERT(fs_event_cb_called == 0); + ASSERT(close_cb_called == 1); /* Cleanup */ remove("watch_dir/file1"); remove("watch_dir/"); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -841,9 +839,9 @@ static void timer_cb(uv_timer_t* handle) { int r; r = uv_fs_event_init(handle->loop, &fs_event); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_fs_event_start(&fs_event, fs_event_fail, ".", 0); - ASSERT_OK(r); + ASSERT(r == 0); uv_close((uv_handle_t*)&fs_event, close_cb); uv_close((uv_handle_t*)handle, close_cb); @@ -861,16 +859,16 @@ TEST_IMPL(fs_event_immediate_close) { loop = uv_default_loop(); r = uv_timer_init(loop, &timer); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_timer_start(&timer, timer_cb, 1, 0); - ASSERT_OK(r); + ASSERT(r == 0); uv_run(loop, UV_RUN_DEFAULT); - ASSERT_EQ(2, close_cb_called); + ASSERT(close_cb_called == 2); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -888,9 +886,9 @@ TEST_IMPL(fs_event_close_with_pending_event) { create_file("watch_dir/file"); r = uv_fs_event_init(loop, &fs_event); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_fs_event_start(&fs_event, fs_event_fail, "watch_dir", 0); - ASSERT_OK(r); + ASSERT(r == 0); /* Generate an fs event. */ touch_file("watch_dir/file"); @@ -899,13 +897,13 @@ TEST_IMPL(fs_event_close_with_pending_event) { uv_run(loop, UV_RUN_DEFAULT); - ASSERT_EQ(1, close_cb_called); + ASSERT(close_cb_called == 1); /* Clean up */ remove("watch_dir/file"); remove("watch_dir/"); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -922,9 +920,9 @@ TEST_IMPL(fs_event_close_with_pending_delete_event) { create_file("watch_dir/file"); r = uv_fs_event_init(loop, &fs_event); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_fs_event_start(&fs_event, fs_event_fail, "watch_dir/file", 0); - ASSERT_OK(r); + ASSERT(r == 0); /* Generate an fs event. */ remove("watch_dir/file"); @@ -938,12 +936,12 @@ TEST_IMPL(fs_event_close_with_pending_delete_event) { uv_run(loop, UV_RUN_DEFAULT); - ASSERT_EQ(1, close_cb_called); + ASSERT(close_cb_called == 1); /* Clean up */ remove("watch_dir/"); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -952,8 +950,6 @@ TEST_IMPL(fs_event_close_in_callback) { RETURN_SKIP(NO_FS_EVENTS); #elif defined(__MVS__) RETURN_SKIP("Directory watching not supported on this platform."); -#elif defined(__APPLE__) && defined(__TSAN__) - RETURN_SKIP("Times out under TSAN."); #endif uv_loop_t* loop; int r; @@ -964,14 +960,14 @@ TEST_IMPL(fs_event_close_in_callback) { create_dir("watch_dir"); r = uv_fs_event_init(loop, &fs_event); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_fs_event_start(&fs_event, fs_event_cb_close, "watch_dir", 0); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_timer_init(loop, &timer); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_timer_start(&timer, fs_event_create_files, 100, 0); - ASSERT_OK(r); + ASSERT(r == 0); uv_run(loop, UV_RUN_DEFAULT); @@ -979,14 +975,14 @@ TEST_IMPL(fs_event_close_in_callback) { uv_run(loop, UV_RUN_ONCE); - ASSERT_EQ(2, close_cb_called); - ASSERT_EQ(3, fs_event_cb_called); + ASSERT(close_cb_called == 2); + ASSERT(fs_event_cb_called == 3); /* Clean up */ fs_event_unlink_files(NULL); remove("watch_dir/"); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -1004,24 +1000,24 @@ TEST_IMPL(fs_event_start_and_close) { create_dir("watch_dir"); r = uv_fs_event_init(loop, &fs_event1); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_fs_event_start(&fs_event1, fs_event_cb_dir, "watch_dir", 0); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_fs_event_init(loop, &fs_event2); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_fs_event_start(&fs_event2, fs_event_cb_dir, "watch_dir", 0); - ASSERT_OK(r); + ASSERT(r == 0); uv_close((uv_handle_t*) &fs_event2, close_cb); uv_close((uv_handle_t*) &fs_event1, close_cb); uv_run(loop, UV_RUN_DEFAULT); - ASSERT_EQ(2, close_cb_called); + ASSERT(close_cb_called == 2); remove("watch_dir/"); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -1048,33 +1044,33 @@ TEST_IMPL(fs_event_getpath) { for (i = 0; i < ARRAY_SIZE(watch_dir); i++) { r = uv_fs_event_init(loop, &fs_event); - ASSERT_OK(r); + ASSERT(r == 0); len = sizeof buf; r = uv_fs_event_getpath(&fs_event, buf, &len); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); r = uv_fs_event_start(&fs_event, fail_cb, watch_dir[i], 0); - ASSERT_OK(r); + ASSERT(r == 0); len = 0; r = uv_fs_event_getpath(&fs_event, buf, &len); - ASSERT_EQ(r, UV_ENOBUFS); - ASSERT_LT(len, sizeof buf); /* sanity check */ - ASSERT_EQ(len, strlen(watch_dir[i]) + 1); + ASSERT(r == UV_ENOBUFS); + ASSERT(len < sizeof buf); /* sanity check */ + ASSERT(len == strlen(watch_dir[i]) + 1); r = uv_fs_event_getpath(&fs_event, buf, &len); - ASSERT_OK(r); - ASSERT_EQ(len, strlen(watch_dir[i])); + ASSERT(r == 0); + ASSERT(len == strlen(watch_dir[i])); ASSERT(strcmp(buf, watch_dir[i]) == 0); r = uv_fs_event_stop(&fs_event); - ASSERT_OK(r); + ASSERT(r == 0); uv_close((uv_handle_t*) &fs_event, close_cb); uv_run(loop, UV_RUN_DEFAULT); - ASSERT_EQ(1, close_cb_called); + ASSERT(close_cb_called == 1); close_cb_called = 0; } remove("watch_dir/"); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -1121,49 +1117,49 @@ TEST_IMPL(fs_event_error_reporting) { */ for (i = 0; i < ARRAY_SIZE(loops); i++) { loop = &loops[i]; - ASSERT_OK(uv_loop_init(loop)); + ASSERT(0 == uv_loop_init(loop)); event = &events[i]; timer_cb_called = 0; close_cb_called = 0; - ASSERT_OK(uv_fs_event_init(loop, event)); - ASSERT_OK(uv_fs_event_start(event, - fs_event_error_report_cb, - "watch_dir", - 0)); + ASSERT(0 == uv_fs_event_init(loop, event)); + ASSERT(0 == uv_fs_event_start(event, + fs_event_error_report_cb, + "watch_dir", + 0)); uv_unref((uv_handle_t*) event); /* Let loop run for some time */ - ASSERT_OK(uv_timer_init(loop, &timer)); - ASSERT_OK(uv_timer_start(&timer, timer_cb_nop, 2, 0)); + ASSERT(0 == uv_timer_init(loop, &timer)); + ASSERT(0 == uv_timer_start(&timer, timer_cb_nop, 2, 0)); uv_run(loop, UV_RUN_DEFAULT); - ASSERT_EQ(1, timer_cb_called); - ASSERT_EQ(1, close_cb_called); + ASSERT(1 == timer_cb_called); + ASSERT(1 == close_cb_called); if (fs_event_error_reported != 0) break; } /* At least one loop should fail */ - ASSERT_EQ(fs_event_error_reported, UV_EMFILE); + ASSERT(fs_event_error_reported == UV_EMFILE); /* Stop and close all events, and destroy loops */ do { loop = &loops[i]; event = &events[i]; - ASSERT_OK(uv_fs_event_stop(event)); + ASSERT(0 == uv_fs_event_stop(event)); uv_ref((uv_handle_t*) event); uv_close((uv_handle_t*) event, fs_event_error_report_close_cb); close_cb_called = 0; uv_run(loop, UV_RUN_DEFAULT); - ASSERT_EQ(1, close_cb_called); + ASSERT(close_cb_called == 1); uv_loop_close(loop); } while (i-- != 0); remove("watch_dir/"); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -1172,7 +1168,7 @@ TEST_IMPL(fs_event_error_reporting) { TEST_IMPL(fs_event_error_reporting) { /* No-op, needed only for FSEvents backend */ - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -1188,14 +1184,14 @@ TEST_IMPL(fs_event_watch_invalid_path) { loop = uv_default_loop(); r = uv_fs_event_init(loop, &fs_event); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_fs_event_start(&fs_event, fs_event_cb_file, "<:;", 0); - ASSERT(r); - ASSERT_OK(uv_is_active((uv_handle_t*) &fs_event)); + ASSERT(r != 0); + ASSERT(uv_is_active((uv_handle_t*) &fs_event) == 0); r = uv_fs_event_start(&fs_event, fs_event_cb_file, "", 0); - ASSERT(r); - ASSERT_OK(uv_is_active((uv_handle_t*) &fs_event)); - MAKE_VALGRIND_HAPPY(loop); + ASSERT(r != 0); + ASSERT(uv_is_active((uv_handle_t*) &fs_event) == 0); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -1219,28 +1215,28 @@ TEST_IMPL(fs_event_stop_in_cb) { remove(path); create_file(path); - ASSERT_OK(uv_fs_event_init(uv_default_loop(), &fs)); - ASSERT_OK(uv_fs_event_start(&fs, fs_event_cb_stop, path, 0)); + ASSERT_EQ(0, uv_fs_event_init(uv_default_loop(), &fs)); + ASSERT_EQ(0, uv_fs_event_start(&fs, fs_event_cb_stop, path, 0)); /* Note: timer_cb_touch() closes the handle. */ timer.data = path; - ASSERT_OK(uv_timer_init(uv_default_loop(), &timer)); - ASSERT_OK(uv_timer_start(&timer, timer_cb_touch, 100, 0)); + ASSERT_EQ(0, uv_timer_init(uv_default_loop(), &timer)); + ASSERT_EQ(0, uv_timer_start(&timer, timer_cb_touch, 100, 0)); - ASSERT_OK(fs_event_cb_stop_calls); - ASSERT_OK(timer_cb_touch_called); + ASSERT_EQ(0, fs_event_cb_stop_calls); + ASSERT_EQ(0, timer_cb_touch_called); - ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT)); + ASSERT_EQ(0, uv_run(uv_default_loop(), UV_RUN_DEFAULT)); ASSERT_EQ(1, fs_event_cb_stop_calls); ASSERT_EQ(1, timer_cb_touch_called); uv_close((uv_handle_t*) &fs, NULL); - ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT)); + ASSERT_EQ(0, uv_run(uv_default_loop(), UV_RUN_DEFAULT)); ASSERT_EQ(1, fs_event_cb_stop_calls); remove(path); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-fs-fd-hash.c b/test/test-fs-fd-hash.c index 4ed3d54..8b4bc03 100644 --- a/test/test-fs-fd-hash.c +++ b/test/test-fs-fd-hash.c @@ -43,7 +43,7 @@ void assert_nonexistent(int fd) { void assert_existent(int fd) { struct uv__fd_info_s info = { 0 }; ASSERT(uv__fd_hash_get(fd, &info)); - ASSERT_EQ(info.flags, fd + FD_DIFF); + ASSERT(info.flags == fd + FD_DIFF); } void assert_insertion(int fd) { @@ -58,7 +58,7 @@ void assert_removal(int fd) { struct uv__fd_info_s info = { 0 }; assert_existent(fd); uv__fd_hash_remove(fd, &info); - ASSERT_EQ(info.flags, fd + FD_DIFF); + ASSERT(info.flags == fd + FD_DIFF); assert_nonexistent(fd); } @@ -106,7 +106,7 @@ TEST_IMPL(fs_fd_hash) { { struct uv__fd_info_s info = { 0 }; ASSERT(uv__fd_hash_get(0, &info)); - ASSERT_EQ(info.flags, FD_DIFF + FD_DIFF); + ASSERT(info.flags == FD_DIFF + FD_DIFF); } { /* Leave as it was, will be again tested below */ diff --git a/test/test-fs-open-flags.c b/test/test-fs-open-flags.c index e64ac20..372afe1 100644 --- a/test/test-fs-open-flags.c +++ b/test/test-fs-open-flags.c @@ -68,8 +68,8 @@ static void setup(void) { uv_fs_req_cleanup(&rmdir_req); r = uv_fs_mkdir(NULL, &mkdir_req, empty_dir, 0755, NULL); - ASSERT_OK(r); - ASSERT_OK(mkdir_req.result); + ASSERT(r == 0); + ASSERT(mkdir_req.result == 0); uv_fs_req_cleanup(&mkdir_req); } @@ -89,13 +89,13 @@ static void refresh(void) { r = uv_fs_open(NULL, &open_req, empty_file, UV_FS_O_TRUNC | UV_FS_O_CREAT | UV_FS_O_WRONLY, S_IWUSR | S_IRUSR, NULL); - ASSERT_GE(r, 0); - ASSERT_GE(open_req.result, 0); + ASSERT(r >= 0); + ASSERT(open_req.result >= 0); uv_fs_req_cleanup(&open_req); r = uv_fs_close(NULL, &close_req, open_req.result, NULL); - ASSERT_OK(r); - ASSERT_OK(close_req.result); + ASSERT(r == 0); + ASSERT(close_req.result == 0); uv_fs_req_cleanup(&close_req); /* dummy_file */ @@ -103,19 +103,19 @@ static void refresh(void) { r = uv_fs_open(NULL, &open_req, dummy_file, UV_FS_O_TRUNC | UV_FS_O_CREAT | UV_FS_O_WRONLY, S_IWUSR | S_IRUSR, NULL); - ASSERT_GE(r, 0); - ASSERT_GE(open_req.result, 0); + ASSERT(r >= 0); + ASSERT(open_req.result >= 0); uv_fs_req_cleanup(&open_req); iov = uv_buf_init("a", 1); r = uv_fs_write(NULL, &write_req, open_req.result, &iov, 1, -1, NULL); - ASSERT_EQ(1, r); - ASSERT_EQ(1, write_req.result); + ASSERT(r == 1); + ASSERT(write_req.result == 1); uv_fs_req_cleanup(&write_req); r = uv_fs_close(NULL, &close_req, open_req.result, NULL); - ASSERT_OK(r); - ASSERT_OK(close_req.result); + ASSERT(r == 0); + ASSERT(close_req.result == 0); uv_fs_req_cleanup(&close_req); } @@ -131,14 +131,14 @@ static void openFail(char *file, int error) { refresh(); r = uv_fs_open(NULL, &open_req, file, flags, S_IWUSR | S_IRUSR, NULL); - ASSERT_EQ(r, error); - ASSERT_EQ(open_req.result, error); + ASSERT(r == error); + ASSERT(open_req.result == error); uv_fs_req_cleanup(&open_req); /* Ensure the first call does not create the file */ r = uv_fs_open(NULL, &open_req, file, flags, S_IWUSR | S_IRUSR, NULL); - ASSERT_EQ(r, error); - ASSERT_EQ(open_req.result, error); + ASSERT(r == error); + ASSERT(open_req.result == error); uv_fs_req_cleanup(&open_req); cleanup(); @@ -150,8 +150,8 @@ static void refreshOpen(char *file) { refresh(); r = uv_fs_open(NULL, &open_req, file, flags, S_IWUSR | S_IRUSR, NULL); - ASSERT_GE(r, 0); - ASSERT_GE(open_req.result, 0); + ASSERT(r >= 0); + ASSERT(open_req.result >= 0); uv_fs_req_cleanup(&open_req); } @@ -162,37 +162,37 @@ static void writeExpect(char *file, char *expected, int size) { iov = uv_buf_init("b", 1); r = uv_fs_write(NULL, &write_req, open_req.result, &iov, 1, -1, NULL); - ASSERT_EQ(1, r); - ASSERT_EQ(1, write_req.result); + ASSERT(r == 1); + ASSERT(write_req.result == 1); uv_fs_req_cleanup(&write_req); iov = uv_buf_init("c", 1); r = uv_fs_write(NULL, &write_req, open_req.result, &iov, 1, -1, NULL); - ASSERT_EQ(1, r); - ASSERT_EQ(1, write_req.result); + ASSERT(r == 1); + ASSERT(write_req.result == 1); uv_fs_req_cleanup(&write_req); r = uv_fs_close(NULL, &close_req, open_req.result, NULL); - ASSERT_OK(r); - ASSERT_OK(close_req.result); + ASSERT(r == 0); + ASSERT(close_req.result == 0); uv_fs_req_cleanup(&close_req); /* Check contents */ r = uv_fs_open(NULL, &open_req, file, UV_FS_O_RDONLY, S_IWUSR | S_IRUSR, NULL); - ASSERT_GE(r, 0); - ASSERT_GE(open_req.result, 0); + ASSERT(r >= 0); + ASSERT(open_req.result >= 0); uv_fs_req_cleanup(&open_req); iov = uv_buf_init(buf, sizeof(buf)); r = uv_fs_read(NULL, &read_req, open_req.result, &iov, 1, -1, NULL); - ASSERT_EQ(r, size); - ASSERT_EQ(read_req.result, size); - ASSERT_OK(strncmp(buf, expected, size)); + ASSERT(r == size); + ASSERT(read_req.result == size); + ASSERT(strncmp(buf, expected, size) == 0); uv_fs_req_cleanup(&read_req); r = uv_fs_close(NULL, &close_req, open_req.result, NULL); - ASSERT_OK(r); - ASSERT_OK(close_req.result); + ASSERT(r == 0); + ASSERT(close_req.result == 0); uv_fs_req_cleanup(&close_req); cleanup(); @@ -205,19 +205,19 @@ static void writeFail(char *file, int error) { iov = uv_buf_init("z", 1); r = uv_fs_write(NULL, &write_req, open_req.result, &iov, 1, -1, NULL); - ASSERT_EQ(r, error); - ASSERT_EQ(write_req.result, error); + ASSERT(r == error); + ASSERT(write_req.result == error); uv_fs_req_cleanup(&write_req); iov = uv_buf_init("z", 1); r = uv_fs_write(NULL, &write_req, open_req.result, &iov, 1, -1, NULL); - ASSERT_EQ(r, error); - ASSERT_EQ(write_req.result, error); + ASSERT(r == error); + ASSERT(write_req.result == error); uv_fs_req_cleanup(&write_req); r = uv_fs_close(NULL, &close_req, open_req.result, NULL); - ASSERT_OK(r); - ASSERT_OK(close_req.result); + ASSERT(r == 0); + ASSERT(close_req.result == 0); uv_fs_req_cleanup(&close_req); cleanup(); @@ -230,14 +230,14 @@ static void readExpect(char *file, char *expected, int size) { iov = uv_buf_init(buf, sizeof(buf)); r = uv_fs_read(NULL, &read_req, open_req.result, &iov, 1, -1, NULL); - ASSERT_EQ(r, size); - ASSERT_EQ(read_req.result, size); - ASSERT_OK(strncmp(buf, expected, size)); + ASSERT(r == size); + ASSERT(read_req.result == size); + ASSERT(strncmp(buf, expected, size) == 0); uv_fs_req_cleanup(&read_req); r = uv_fs_close(NULL, &close_req, open_req.result, NULL); - ASSERT_OK(r); - ASSERT_OK(close_req.result); + ASSERT(r == 0); + ASSERT(close_req.result == 0); uv_fs_req_cleanup(&close_req); cleanup(); @@ -250,19 +250,19 @@ static void readFail(char *file, int error) { iov = uv_buf_init(buf, sizeof(buf)); r = uv_fs_read(NULL, &read_req, open_req.result, &iov, 1, -1, NULL); - ASSERT_EQ(r, error); - ASSERT_EQ(read_req.result, error); + ASSERT(r == error); + ASSERT(read_req.result == error); uv_fs_req_cleanup(&read_req); iov = uv_buf_init(buf, sizeof(buf)); r = uv_fs_read(NULL, &read_req, open_req.result, &iov, 1, -1, NULL); - ASSERT_EQ(r, error); - ASSERT_EQ(read_req.result, error); + ASSERT(r == error); + ASSERT(read_req.result == error); uv_fs_req_cleanup(&read_req); r = uv_fs_close(NULL, &close_req, open_req.result, NULL); - ASSERT_OK(r); - ASSERT_OK(close_req.result); + ASSERT(r == 0); + ASSERT(close_req.result == 0); uv_fs_req_cleanup(&close_req); cleanup(); @@ -424,7 +424,7 @@ TEST_IMPL(fs_open_flags) { /* Cleanup. */ rmdir(empty_dir); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-fs-poll.c b/test/test-fs-poll.c index 5f95baf..76fe6fc 100644 --- a/test/test-fs-poll.c +++ b/test/test-fs-poll.c @@ -103,44 +103,44 @@ static void poll_cb(uv_fs_poll_t* handle, memset(&zero_statbuf, 0, sizeof(zero_statbuf)); - ASSERT_PTR_EQ(handle, &poll_handle); - ASSERT_EQ(1, uv_is_active((uv_handle_t*) handle)); + ASSERT(handle == &poll_handle); + ASSERT(1 == uv_is_active((uv_handle_t*) handle)); ASSERT_NOT_NULL(prev); ASSERT_NOT_NULL(curr); switch (poll_cb_called++) { case 0: - ASSERT_EQ(status, UV_ENOENT); - ASSERT_OK(memcmp(prev, &zero_statbuf, sizeof(zero_statbuf))); - ASSERT_OK(memcmp(curr, &zero_statbuf, sizeof(zero_statbuf))); + ASSERT(status == UV_ENOENT); + ASSERT(0 == memcmp(prev, &zero_statbuf, sizeof(zero_statbuf))); + ASSERT(0 == memcmp(curr, &zero_statbuf, sizeof(zero_statbuf))); touch_file(FIXTURE); break; case 1: - ASSERT_OK(status); - ASSERT_OK(memcmp(prev, &zero_statbuf, sizeof(zero_statbuf))); - ASSERT_NE(0, memcmp(curr, &zero_statbuf, sizeof(zero_statbuf))); - ASSERT_OK(uv_timer_start(&timer_handle, timer_cb, 20, 0)); + ASSERT(status == 0); + ASSERT(0 == memcmp(prev, &zero_statbuf, sizeof(zero_statbuf))); + ASSERT(0 != memcmp(curr, &zero_statbuf, sizeof(zero_statbuf))); + ASSERT(0 == uv_timer_start(&timer_handle, timer_cb, 20, 0)); break; case 2: - ASSERT_OK(status); - ASSERT_NE(0, memcmp(prev, &zero_statbuf, sizeof(zero_statbuf))); - ASSERT_NE(0, memcmp(curr, &zero_statbuf, sizeof(zero_statbuf))); - ASSERT_OK(uv_timer_start(&timer_handle, timer_cb, 200, 0)); + ASSERT(status == 0); + ASSERT(0 != memcmp(prev, &zero_statbuf, sizeof(zero_statbuf))); + ASSERT(0 != memcmp(curr, &zero_statbuf, sizeof(zero_statbuf))); + ASSERT(0 == uv_timer_start(&timer_handle, timer_cb, 200, 0)); break; case 3: - ASSERT_OK(status); - ASSERT_NE(0, memcmp(prev, &zero_statbuf, sizeof(zero_statbuf))); - ASSERT_NE(0, memcmp(curr, &zero_statbuf, sizeof(zero_statbuf))); + ASSERT(status == 0); + ASSERT(0 != memcmp(prev, &zero_statbuf, sizeof(zero_statbuf))); + ASSERT(0 != memcmp(curr, &zero_statbuf, sizeof(zero_statbuf))); remove(FIXTURE); break; case 4: - ASSERT_EQ(status, UV_ENOENT); - ASSERT_NE(0, memcmp(prev, &zero_statbuf, sizeof(zero_statbuf))); - ASSERT_OK(memcmp(curr, &zero_statbuf, sizeof(zero_statbuf))); + ASSERT(status == UV_ENOENT); + ASSERT(0 != memcmp(prev, &zero_statbuf, sizeof(zero_statbuf))); + ASSERT(0 == memcmp(curr, &zero_statbuf, sizeof(zero_statbuf))); uv_close((uv_handle_t*)handle, close_cb); break; @@ -155,16 +155,16 @@ TEST_IMPL(fs_poll) { remove(FIXTURE); - ASSERT_OK(uv_timer_init(loop, &timer_handle)); - ASSERT_OK(uv_fs_poll_init(loop, &poll_handle)); - ASSERT_OK(uv_fs_poll_start(&poll_handle, poll_cb, FIXTURE, 100)); - ASSERT_OK(uv_run(loop, UV_RUN_DEFAULT)); + ASSERT(0 == uv_timer_init(loop, &timer_handle)); + ASSERT(0 == uv_fs_poll_init(loop, &poll_handle)); + ASSERT(0 == uv_fs_poll_start(&poll_handle, poll_cb, FIXTURE, 100)); + ASSERT(0 == uv_run(loop, UV_RUN_DEFAULT)); - ASSERT_EQ(5, poll_cb_called); - ASSERT_EQ(2, timer_cb_called); - ASSERT_EQ(1, close_cb_called); + ASSERT(poll_cb_called == 5); + ASSERT(timer_cb_called == 2); + ASSERT(close_cb_called == 1); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -176,23 +176,23 @@ TEST_IMPL(fs_poll_getpath) { remove(FIXTURE); - ASSERT_OK(uv_fs_poll_init(loop, &poll_handle)); + ASSERT(0 == uv_fs_poll_init(loop, &poll_handle)); len = sizeof buf; - ASSERT_EQ(UV_EINVAL, uv_fs_poll_getpath(&poll_handle, buf, &len)); - ASSERT_OK(uv_fs_poll_start(&poll_handle, poll_cb_fail, FIXTURE, 100)); + ASSERT(UV_EINVAL == uv_fs_poll_getpath(&poll_handle, buf, &len)); + ASSERT(0 == uv_fs_poll_start(&poll_handle, poll_cb_fail, FIXTURE, 100)); len = sizeof buf; - ASSERT_OK(uv_fs_poll_getpath(&poll_handle, buf, &len)); - ASSERT_NE(0, buf[len - 1]); - ASSERT_EQ(buf[len], '\0'); - ASSERT_OK(memcmp(buf, FIXTURE, len)); + ASSERT(0 == uv_fs_poll_getpath(&poll_handle, buf, &len)); + ASSERT(buf[len - 1] != 0); + ASSERT(buf[len] == '\0'); + ASSERT(0 == memcmp(buf, FIXTURE, len)); uv_close((uv_handle_t*) &poll_handle, close_cb); - ASSERT_OK(uv_run(loop, UV_RUN_DEFAULT)); + ASSERT(0 == uv_run(loop, UV_RUN_DEFAULT)); - ASSERT_EQ(1, close_cb_called); + ASSERT(close_cb_called == 1); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -203,16 +203,18 @@ TEST_IMPL(fs_poll_close_request) { remove(FIXTURE); - ASSERT_OK(uv_loop_init(&loop)); + ASSERT(0 == uv_loop_init(&loop)); - ASSERT_OK(uv_fs_poll_init(&loop, &poll_handle)); - ASSERT_OK(uv_fs_poll_start(&poll_handle, poll_cb_fail, FIXTURE, 100)); + ASSERT(0 == uv_fs_poll_init(&loop, &poll_handle)); + ASSERT(0 == uv_fs_poll_start(&poll_handle, poll_cb_fail, FIXTURE, 100)); uv_close((uv_handle_t*) &poll_handle, close_cb); while (close_cb_called == 0) uv_run(&loop, UV_RUN_ONCE); - ASSERT_EQ(1, close_cb_called); + ASSERT(close_cb_called == 1); - MAKE_VALGRIND_HAPPY(&loop); + ASSERT(0 == uv_loop_close(&loop)); + + MAKE_VALGRIND_HAPPY(); return 0; } @@ -223,20 +225,22 @@ TEST_IMPL(fs_poll_close_request_multi_start_stop) { remove(FIXTURE); - ASSERT_OK(uv_loop_init(&loop)); + ASSERT(0 == uv_loop_init(&loop)); - ASSERT_OK(uv_fs_poll_init(&loop, &poll_handle)); + ASSERT(0 == uv_fs_poll_init(&loop, &poll_handle)); for (i = 0; i < 10; ++i) { - ASSERT_OK(uv_fs_poll_start(&poll_handle, poll_cb_fail, FIXTURE, 100)); - ASSERT_OK(uv_fs_poll_stop(&poll_handle)); + ASSERT(0 == uv_fs_poll_start(&poll_handle, poll_cb_fail, FIXTURE, 100)); + ASSERT(0 == uv_fs_poll_stop(&poll_handle)); } uv_close((uv_handle_t*) &poll_handle, close_cb); while (close_cb_called == 0) uv_run(&loop, UV_RUN_ONCE); - ASSERT_EQ(1, close_cb_called); + ASSERT(close_cb_called == 1); + + ASSERT(0 == uv_loop_close(&loop)); - MAKE_VALGRIND_HAPPY(&loop); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -247,20 +251,22 @@ TEST_IMPL(fs_poll_close_request_multi_stop_start) { remove(FIXTURE); - ASSERT_OK(uv_loop_init(&loop)); + ASSERT(0 == uv_loop_init(&loop)); - ASSERT_OK(uv_fs_poll_init(&loop, &poll_handle)); + ASSERT(0 == uv_fs_poll_init(&loop, &poll_handle)); for (i = 0; i < 10; ++i) { - ASSERT_OK(uv_fs_poll_stop(&poll_handle)); - ASSERT_OK(uv_fs_poll_start(&poll_handle, poll_cb_fail, FIXTURE, 100)); + ASSERT(0 == uv_fs_poll_stop(&poll_handle)); + ASSERT(0 == uv_fs_poll_start(&poll_handle, poll_cb_fail, FIXTURE, 100)); } uv_close((uv_handle_t*) &poll_handle, close_cb); while (close_cb_called == 0) uv_run(&loop, UV_RUN_ONCE); - ASSERT_EQ(1, close_cb_called); + ASSERT(close_cb_called == 1); - MAKE_VALGRIND_HAPPY(&loop); + ASSERT(0 == uv_loop_close(&loop)); + + MAKE_VALGRIND_HAPPY(); return 0; } @@ -271,22 +277,24 @@ TEST_IMPL(fs_poll_close_request_stop_when_active) { remove(FIXTURE); - ASSERT_OK(uv_loop_init(&loop)); + ASSERT(0 == uv_loop_init(&loop)); /* Set up all handles. */ - ASSERT_OK(uv_fs_poll_init(&loop, &poll_handle)); - ASSERT_OK(uv_fs_poll_start(&poll_handle, poll_cb_noop, FIXTURE, 100)); + ASSERT(0 == uv_fs_poll_init(&loop, &poll_handle)); + ASSERT(0 == uv_fs_poll_start(&poll_handle, poll_cb_noop, FIXTURE, 100)); uv_run(&loop, UV_RUN_ONCE); /* Close the timer handle, and do not crash. */ - ASSERT_OK(uv_fs_poll_stop(&poll_handle)); + ASSERT(0 == uv_fs_poll_stop(&poll_handle)); uv_run(&loop, UV_RUN_ONCE); /* Clean up after the test. */ uv_close((uv_handle_t*) &poll_handle, close_cb); uv_run(&loop, UV_RUN_ONCE); - ASSERT_EQ(1, close_cb_called); + ASSERT(close_cb_called == 1); + + ASSERT(0 == uv_loop_close(&loop)); - MAKE_VALGRIND_HAPPY(&loop); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-fs-readdir.c b/test/test-fs-readdir.c index 0f2b4af..6bb6917 100644 --- a/test/test-fs-readdir.c +++ b/test/test-fs-readdir.c @@ -47,9 +47,9 @@ static void cleanup_test_files(void) { } static void empty_closedir_cb(uv_fs_t* req) { - ASSERT_PTR_EQ(req, &closedir_req); - ASSERT_EQ(req->fs_type, UV_FS_CLOSEDIR); - ASSERT_OK(req->result); + ASSERT(req == &closedir_req); + ASSERT(req->fs_type == UV_FS_CLOSEDIR); + ASSERT(req->result == 0); ++empty_closedir_cb_count; uv_fs_req_cleanup(req); } @@ -58,25 +58,25 @@ static void empty_readdir_cb(uv_fs_t* req) { uv_dir_t* dir; int r; - ASSERT_PTR_EQ(req, &readdir_req); - ASSERT_EQ(req->fs_type, UV_FS_READDIR); - ASSERT_OK(req->result); + ASSERT(req == &readdir_req); + ASSERT(req->fs_type == UV_FS_READDIR); + ASSERT(req->result == 0); dir = req->ptr; uv_fs_req_cleanup(req); r = uv_fs_closedir(uv_default_loop(), &closedir_req, dir, empty_closedir_cb); - ASSERT_OK(r); + ASSERT(r == 0); } static void empty_opendir_cb(uv_fs_t* req) { uv_dir_t* dir; int r; - ASSERT_PTR_EQ(req, &opendir_req); - ASSERT_EQ(req->fs_type, UV_FS_OPENDIR); - ASSERT_OK(req->result); + ASSERT(req == &opendir_req); + ASSERT(req->fs_type == UV_FS_OPENDIR); + ASSERT(req->result == 0); ASSERT_NOT_NULL(req->ptr); dir = req->ptr; dir->dirents = dirents; @@ -85,7 +85,7 @@ static void empty_opendir_cb(uv_fs_t* req) { &readdir_req, dir, empty_readdir_cb); - ASSERT_OK(r); + ASSERT(r == 0); uv_fs_req_cleanup(req); ++empty_opendir_cb_count; } @@ -115,9 +115,9 @@ TEST_IMPL(fs_readdir_empty_dir) { &opendir_req, path, NULL); - ASSERT_OK(r); - ASSERT_EQ(opendir_req.fs_type, UV_FS_OPENDIR); - ASSERT_OK(opendir_req.result); + ASSERT(r == 0); + ASSERT(opendir_req.fs_type == UV_FS_OPENDIR); + ASSERT(opendir_req.result == 0); ASSERT_NOT_NULL(opendir_req.ptr); dir = opendir_req.ptr; uv_fs_req_cleanup(&opendir_req); @@ -130,13 +130,13 @@ TEST_IMPL(fs_readdir_empty_dir) { &readdir_req, dir, NULL); - ASSERT_OK(nb_entries_read); + ASSERT(nb_entries_read == 0); uv_fs_req_cleanup(&readdir_req); /* Fill the req to ensure that required fields are cleaned up. */ memset(&closedir_req, 0xdb, sizeof(closedir_req)); uv_fs_closedir(uv_default_loop(), &closedir_req, dir, NULL); - ASSERT_OK(closedir_req.result); + ASSERT(closedir_req.result == 0); uv_fs_req_cleanup(&closedir_req); /* Testing the asynchronous flavor. */ @@ -147,16 +147,16 @@ TEST_IMPL(fs_readdir_empty_dir) { memset(&closedir_req, 0xdb, sizeof(closedir_req)); r = uv_fs_opendir(uv_default_loop(), &opendir_req, path, empty_opendir_cb); - ASSERT_OK(r); - ASSERT_OK(empty_opendir_cb_count); - ASSERT_OK(empty_closedir_cb_count); + ASSERT(r == 0); + ASSERT(empty_opendir_cb_count == 0); + ASSERT(empty_closedir_cb_count == 0); r = uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_OK(r); - ASSERT_EQ(1, empty_opendir_cb_count); - ASSERT_EQ(1, empty_closedir_cb_count); + ASSERT(r == 0); + ASSERT(empty_opendir_cb_count == 1); + ASSERT(empty_closedir_cb_count == 1); uv_fs_rmdir(uv_default_loop(), &rmdir_req, path, NULL); uv_fs_req_cleanup(&rmdir_req); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -168,9 +168,9 @@ TEST_IMPL(fs_readdir_empty_dir) { static int non_existing_opendir_cb_count; static void non_existing_opendir_cb(uv_fs_t* req) { - ASSERT_PTR_EQ(req, &opendir_req); - ASSERT_EQ(req->fs_type, UV_FS_OPENDIR); - ASSERT_EQ(req->result, UV_ENOENT); + ASSERT(req == &opendir_req); + ASSERT(req->fs_type == UV_FS_OPENDIR); + ASSERT(req->result == UV_ENOENT); ASSERT_NULL(req->ptr); uv_fs_req_cleanup(req); @@ -188,9 +188,9 @@ TEST_IMPL(fs_readdir_non_existing_dir) { /* Testing the synchronous flavor. */ r = uv_fs_opendir(uv_default_loop(), &opendir_req, path, NULL); - ASSERT_EQ(r, UV_ENOENT); - ASSERT_EQ(opendir_req.fs_type, UV_FS_OPENDIR); - ASSERT_EQ(opendir_req.result, UV_ENOENT); + ASSERT(r == UV_ENOENT); + ASSERT(opendir_req.fs_type == UV_FS_OPENDIR); + ASSERT(opendir_req.result == UV_ENOENT); ASSERT_NULL(opendir_req.ptr); uv_fs_req_cleanup(&opendir_req); @@ -202,13 +202,13 @@ TEST_IMPL(fs_readdir_non_existing_dir) { &opendir_req, path, non_existing_opendir_cb); - ASSERT_OK(r); - ASSERT_OK(non_existing_opendir_cb_count); + ASSERT(r == 0); + ASSERT(non_existing_opendir_cb_count == 0); r = uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_OK(r); - ASSERT_EQ(1, non_existing_opendir_cb_count); + ASSERT(r == 0); + ASSERT(non_existing_opendir_cb_count == 1); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -220,9 +220,9 @@ TEST_IMPL(fs_readdir_non_existing_dir) { static int file_opendir_cb_count; static void file_opendir_cb(uv_fs_t* req) { - ASSERT_PTR_EQ(req, &opendir_req); - ASSERT_EQ(req->fs_type, UV_FS_OPENDIR); - ASSERT_EQ(req->result, UV_ENOTDIR); + ASSERT(req == &opendir_req); + ASSERT(req->fs_type == UV_FS_OPENDIR); + ASSERT(req->result == UV_ENOTDIR); ASSERT_NULL(req->ptr); uv_fs_req_cleanup(req); @@ -241,9 +241,9 @@ TEST_IMPL(fs_readdir_file) { /* Testing the synchronous flavor. */ r = uv_fs_opendir(uv_default_loop(), &opendir_req, path, NULL); - ASSERT_EQ(r, UV_ENOTDIR); - ASSERT_EQ(opendir_req.fs_type, UV_FS_OPENDIR); - ASSERT_EQ(opendir_req.result, UV_ENOTDIR); + ASSERT(r == UV_ENOTDIR); + ASSERT(opendir_req.fs_type == UV_FS_OPENDIR); + ASSERT(opendir_req.result == UV_ENOTDIR); ASSERT_NULL(opendir_req.ptr); uv_fs_req_cleanup(&opendir_req); @@ -253,12 +253,12 @@ TEST_IMPL(fs_readdir_file) { /* Testing the async flavor. */ r = uv_fs_opendir(uv_default_loop(), &opendir_req, path, file_opendir_cb); - ASSERT_OK(r); - ASSERT_OK(file_opendir_cb_count); + ASSERT(r == 0); + ASSERT(file_opendir_cb_count == 0); r = uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_OK(r); - ASSERT_EQ(1, file_opendir_cb_count); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + ASSERT(r == 0); + ASSERT(file_opendir_cb_count == 1); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -273,8 +273,8 @@ static int non_empty_readdir_cb_count; static int non_empty_closedir_cb_count; static void non_empty_closedir_cb(uv_fs_t* req) { - ASSERT_PTR_EQ(req, &closedir_req); - ASSERT_OK(req->result); + ASSERT(req == &closedir_req); + ASSERT(req->result == 0); uv_fs_req_cleanup(req); ++non_empty_closedir_cb_count; } @@ -282,30 +282,30 @@ static void non_empty_closedir_cb(uv_fs_t* req) { static void non_empty_readdir_cb(uv_fs_t* req) { uv_dir_t* dir; - ASSERT_PTR_EQ(req, &readdir_req); - ASSERT_EQ(req->fs_type, UV_FS_READDIR); + ASSERT(req == &readdir_req); + ASSERT(req->fs_type == UV_FS_READDIR); dir = req->ptr; if (req->result == 0) { uv_fs_req_cleanup(req); - ASSERT_EQ(3, non_empty_readdir_cb_count); + ASSERT(non_empty_readdir_cb_count == 3); uv_fs_closedir(uv_default_loop(), &closedir_req, dir, non_empty_closedir_cb); } else { - ASSERT_EQ(1, req->result); - ASSERT_PTR_EQ(dir->dirents, dirents); + ASSERT(req->result == 1); + ASSERT(dir->dirents == dirents); ASSERT(strcmp(dirents[0].name, "file1") == 0 || strcmp(dirents[0].name, "file2") == 0 || strcmp(dirents[0].name, "test_subdir") == 0); #ifdef HAVE_DIRENT_TYPES if (!strcmp(dirents[0].name, "test_subdir")) - ASSERT_EQ(dirents[0].type, UV_DIRENT_DIR); + ASSERT(dirents[0].type == UV_DIRENT_DIR); else - ASSERT_EQ(dirents[0].type, UV_DIRENT_FILE); + ASSERT(dirents[0].type == UV_DIRENT_FILE); #else - ASSERT_EQ(dirents[0].type, UV_DIRENT_UNKNOWN); + ASSERT(dirents[0].type == UV_DIRENT_UNKNOWN); #endif /* HAVE_DIRENT_TYPES */ ++non_empty_readdir_cb_count; @@ -323,9 +323,9 @@ static void non_empty_opendir_cb(uv_fs_t* req) { uv_dir_t* dir; int r; - ASSERT_PTR_EQ(req, &opendir_req); - ASSERT_EQ(req->fs_type, UV_FS_OPENDIR); - ASSERT_OK(req->result); + ASSERT(req == &opendir_req); + ASSERT(req->fs_type == UV_FS_OPENDIR); + ASSERT(req->result == 0); ASSERT_NOT_NULL(req->ptr); dir = req->ptr; @@ -336,7 +336,7 @@ static void non_empty_opendir_cb(uv_fs_t* req) { &readdir_req, dir, non_empty_readdir_cb); - ASSERT_OK(r); + ASSERT(r == 0); uv_fs_req_cleanup(req); ++non_empty_opendir_cb_count; } @@ -353,35 +353,35 @@ TEST_IMPL(fs_readdir_non_empty_dir) { cleanup_test_files(); r = uv_fs_mkdir(uv_default_loop(), &mkdir_req, "test_dir", 0755, NULL); - ASSERT_OK(r); + ASSERT(r == 0); /* Create two files synchronously. */ r = uv_fs_open(uv_default_loop(), &create_req, "test_dir/file1", - UV_FS_O_WRONLY | UV_FS_O_CREAT, S_IWUSR | S_IRUSR, + O_WRONLY | O_CREAT, S_IWUSR | S_IRUSR, NULL); - ASSERT_GE(r, 0); + ASSERT(r >= 0); uv_fs_req_cleanup(&create_req); r = uv_fs_close(uv_default_loop(), &close_req, create_req.result, NULL); - ASSERT_OK(r); + ASSERT(r == 0); uv_fs_req_cleanup(&close_req); r = uv_fs_open(uv_default_loop(), &create_req, "test_dir/file2", - UV_FS_O_WRONLY | UV_FS_O_CREAT, S_IWUSR | S_IRUSR, + O_WRONLY | O_CREAT, S_IWUSR | S_IRUSR, NULL); - ASSERT_GE(r, 0); + ASSERT(r >= 0); uv_fs_req_cleanup(&create_req); r = uv_fs_close(uv_default_loop(), &close_req, create_req.result, NULL); - ASSERT_OK(r); + ASSERT(r == 0); uv_fs_req_cleanup(&close_req); r = uv_fs_mkdir(uv_default_loop(), @@ -389,7 +389,7 @@ TEST_IMPL(fs_readdir_non_empty_dir) { "test_dir/test_subdir", 0755, NULL); - ASSERT_OK(r); + ASSERT(r == 0); uv_fs_req_cleanup(&mkdir_req); /* Fill the req to ensure that required fields are cleaned up. */ @@ -397,9 +397,9 @@ TEST_IMPL(fs_readdir_non_empty_dir) { /* Testing the synchronous flavor. */ r = uv_fs_opendir(uv_default_loop(), &opendir_req, "test_dir", NULL); - ASSERT_OK(r); - ASSERT_EQ(opendir_req.fs_type, UV_FS_OPENDIR); - ASSERT_OK(opendir_req.result); + ASSERT(r == 0); + ASSERT(opendir_req.fs_type == UV_FS_OPENDIR); + ASSERT(opendir_req.result == 0); ASSERT_NOT_NULL(opendir_req.ptr); entries_count = 0; @@ -417,23 +417,23 @@ TEST_IMPL(fs_readdir_non_empty_dir) { strcmp(dirents[0].name, "test_subdir") == 0); #ifdef HAVE_DIRENT_TYPES if (!strcmp(dirents[0].name, "test_subdir")) - ASSERT_EQ(dirents[0].type, UV_DIRENT_DIR); + ASSERT(dirents[0].type == UV_DIRENT_DIR); else - ASSERT_EQ(dirents[0].type, UV_DIRENT_FILE); + ASSERT(dirents[0].type == UV_DIRENT_FILE); #else - ASSERT_EQ(dirents[0].type, UV_DIRENT_UNKNOWN); + ASSERT(dirents[0].type == UV_DIRENT_UNKNOWN); #endif /* HAVE_DIRENT_TYPES */ uv_fs_req_cleanup(&readdir_req); ++entries_count; } - ASSERT_EQ(3, entries_count); + ASSERT(entries_count == 3); uv_fs_req_cleanup(&readdir_req); /* Fill the req to ensure that required fields are cleaned up. */ memset(&closedir_req, 0xdb, sizeof(closedir_req)); uv_fs_closedir(uv_default_loop(), &closedir_req, dir, NULL); - ASSERT_OK(closedir_req.result); + ASSERT(closedir_req.result == 0); uv_fs_req_cleanup(&closedir_req); /* Testing the asynchronous flavor. */ @@ -445,18 +445,18 @@ TEST_IMPL(fs_readdir_non_empty_dir) { &opendir_req, "test_dir", non_empty_opendir_cb); - ASSERT_OK(r); - ASSERT_OK(non_empty_opendir_cb_count); - ASSERT_OK(non_empty_closedir_cb_count); + ASSERT(r == 0); + ASSERT(non_empty_opendir_cb_count == 0); + ASSERT(non_empty_closedir_cb_count == 0); r = uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_OK(r); - ASSERT_EQ(1, non_empty_opendir_cb_count); - ASSERT_EQ(1, non_empty_closedir_cb_count); + ASSERT(r == 0); + ASSERT(non_empty_opendir_cb_count == 1); + ASSERT(non_empty_closedir_cb_count == 1); uv_fs_rmdir(uv_default_loop(), &rmdir_req, "test_subdir", NULL); uv_fs_req_cleanup(&rmdir_req); cleanup_test_files(); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-fs.c b/test/test-fs.c index fe78117..0bf6c05 100644 --- a/test/test-fs.c +++ b/test/test-fs.c @@ -37,9 +37,6 @@ # ifndef ERROR_SYMLINK_NOT_SUPPORTED # define ERROR_SYMLINK_NOT_SUPPORTED 1464 # endif -# ifndef S_IFIFO -# define S_IFIFO _S_IFIFO -# endif # define unlink _unlink # define rmdir _rmdir # define open _open @@ -51,9 +48,6 @@ # ifndef lseek # define lseek _lseek # endif -# define S_IFDIR _S_IFDIR -# define S_IFCHR _S_IFCHR -# define S_IFREG _S_IFREG #endif #define TOO_LONG_NAME_LENGTH 65536 @@ -88,9 +82,6 @@ static int fstat_cb_count; static int access_cb_count; static int chmod_cb_count; static int fchmod_cb_count; -static int chown_cb_count; -static int fchown_cb_count; -static int lchown_cb_count; static int link_cb_count; static int symlink_cb_count; static int readlink_cb_count; @@ -173,8 +164,8 @@ static void check_permission(const char* filename, unsigned int mode) { uv_stat_t* s; r = uv_fs_stat(NULL, &req, filename, NULL); - ASSERT_OK(r); - ASSERT_OK(req.result); + ASSERT(r == 0); + ASSERT(req.result == 0); s = &req.statbuf; #if defined(_WIN32) || defined(__CYGWIN__) || defined(__MSYS__) @@ -198,24 +189,24 @@ static void dummy_cb(uv_fs_t* req) { static void link_cb(uv_fs_t* req) { - ASSERT_EQ(req->fs_type, UV_FS_LINK); - ASSERT_OK(req->result); + ASSERT(req->fs_type == UV_FS_LINK); + ASSERT(req->result == 0); link_cb_count++; uv_fs_req_cleanup(req); } static void symlink_cb(uv_fs_t* req) { - ASSERT_EQ(req->fs_type, UV_FS_SYMLINK); - ASSERT_OK(req->result); + ASSERT(req->fs_type == UV_FS_SYMLINK); + ASSERT(req->result == 0); symlink_cb_count++; uv_fs_req_cleanup(req); } static void readlink_cb(uv_fs_t* req) { - ASSERT_EQ(req->fs_type, UV_FS_READLINK); - ASSERT_OK(req->result); - ASSERT_OK(strcmp(req->ptr, "test_file_symlink2")); + ASSERT(req->fs_type == UV_FS_READLINK); + ASSERT(req->result == 0); + ASSERT(strcmp(req->ptr, "test_file_symlink2") == 0); readlink_cb_count++; uv_fs_req_cleanup(req); } @@ -224,16 +215,26 @@ static void readlink_cb(uv_fs_t* req) { static void realpath_cb(uv_fs_t* req) { char test_file_abs_buf[PATHMAX]; size_t test_file_abs_size = sizeof(test_file_abs_buf); - ASSERT_EQ(req->fs_type, UV_FS_REALPATH); - ASSERT_OK(req->result); + ASSERT(req->fs_type == UV_FS_REALPATH); +#ifdef _WIN32 + /* + * Windows XP and Server 2003 don't support GetFinalPathNameByHandleW() + */ + if (req->result == UV_ENOSYS) { + realpath_cb_count++; + uv_fs_req_cleanup(req); + return; + } +#endif + ASSERT(req->result == 0); uv_cwd(test_file_abs_buf, &test_file_abs_size); #ifdef _WIN32 strcat(test_file_abs_buf, "\\test_file"); - ASSERT_OK(_stricmp(req->ptr, test_file_abs_buf)); + ASSERT(stricmp(req->ptr, test_file_abs_buf) == 0); #else strcat(test_file_abs_buf, "/test_file"); - ASSERT_OK(strcmp(req->ptr, test_file_abs_buf)); + ASSERT(strcmp(req->ptr, test_file_abs_buf) == 0); #endif realpath_cb_count++; uv_fs_req_cleanup(req); @@ -241,15 +242,15 @@ static void realpath_cb(uv_fs_t* req) { static void access_cb(uv_fs_t* req) { - ASSERT_EQ(req->fs_type, UV_FS_ACCESS); + ASSERT(req->fs_type == UV_FS_ACCESS); access_cb_count++; uv_fs_req_cleanup(req); } static void fchmod_cb(uv_fs_t* req) { - ASSERT_EQ(req->fs_type, UV_FS_FCHMOD); - ASSERT_OK(req->result); + ASSERT(req->fs_type == UV_FS_FCHMOD); + ASSERT(req->result == 0); fchmod_cb_count++; uv_fs_req_cleanup(req); check_permission("test_file", *(int*)req->data); @@ -257,78 +258,27 @@ static void fchmod_cb(uv_fs_t* req) { static void chmod_cb(uv_fs_t* req) { - ASSERT_EQ(req->fs_type, UV_FS_CHMOD); - ASSERT_OK(req->result); + ASSERT(req->fs_type == UV_FS_CHMOD); + ASSERT(req->result == 0); chmod_cb_count++; uv_fs_req_cleanup(req); check_permission("test_file", *(int*)req->data); } -static void fchown_cb(uv_fs_t* req) { - ASSERT_EQ(req->fs_type, UV_FS_FCHOWN); - ASSERT_OK(req->result); - fchown_cb_count++; - uv_fs_req_cleanup(req); -} - - -static void chown_cb(uv_fs_t* req) { - ASSERT_EQ(req->fs_type, UV_FS_CHOWN); - ASSERT_OK(req->result); - chown_cb_count++; - uv_fs_req_cleanup(req); -} - -static void lchown_cb(uv_fs_t* req) { - ASSERT_EQ(req->fs_type, UV_FS_LCHOWN); - ASSERT_OK(req->result); - lchown_cb_count++; - uv_fs_req_cleanup(req); -} - -static void chown_root_cb(uv_fs_t* req) { - ASSERT_EQ(req->fs_type, UV_FS_CHOWN); -#if defined(_WIN32) || defined(__MSYS__) - /* On windows, chown is a no-op and always succeeds. */ - ASSERT_OK(req->result); -#else - /* On unix, chown'ing the root directory is not allowed - - * unless you're root, of course. - */ - if (geteuid() == 0) - ASSERT_OK(req->result); - else -# if defined(__CYGWIN__) - /* On Cygwin, uid 0 is invalid (no root). */ - ASSERT_EQ(req->result, UV_EINVAL); -# elif defined(__PASE__) - /* On IBMi PASE, there is no root user. uid 0 is user qsecofr. - * User may grant qsecofr's privileges, including changing - * the file's ownership to uid 0. - */ - ASSERT(req->result == 0 || req->result == UV_EPERM); -# else - ASSERT_EQ(req->result, UV_EPERM); -# endif -#endif - chown_cb_count++; - uv_fs_req_cleanup(req); -} - static void unlink_cb(uv_fs_t* req) { - ASSERT_PTR_EQ(req, &unlink_req); - ASSERT_EQ(req->fs_type, UV_FS_UNLINK); - ASSERT_OK(req->result); + ASSERT(req == &unlink_req); + ASSERT(req->fs_type == UV_FS_UNLINK); + ASSERT(req->result == 0); unlink_cb_count++; uv_fs_req_cleanup(req); } static void fstat_cb(uv_fs_t* req) { uv_stat_t* s = req->ptr; - ASSERT_EQ(req->fs_type, UV_FS_FSTAT); - ASSERT_OK(req->result); - ASSERT_EQ(s->st_size, sizeof(test_buf)); + ASSERT(req->fs_type == UV_FS_FSTAT); + ASSERT(req->result == 0); + ASSERT(s->st_size == sizeof(test_buf)); uv_fs_req_cleanup(req); fstat_cb_count++; } @@ -337,29 +287,29 @@ static void fstat_cb(uv_fs_t* req) { static void statfs_cb(uv_fs_t* req) { uv_statfs_t* stats; - ASSERT_EQ(req->fs_type, UV_FS_STATFS); - ASSERT_OK(req->result); + ASSERT(req->fs_type == UV_FS_STATFS); + ASSERT(req->result == 0); ASSERT_NOT_NULL(req->ptr); stats = req->ptr; #if defined(_WIN32) || defined(__sun) || defined(_AIX) || defined(__MVS__) || \ defined(__OpenBSD__) || defined(__NetBSD__) - ASSERT_OK(stats->f_type); + ASSERT(stats->f_type == 0); #else - ASSERT_UINT64_GT(stats->f_type, 0); + ASSERT(stats->f_type > 0); #endif - ASSERT_GT(stats->f_bsize, 0); - ASSERT_GT(stats->f_blocks, 0); - ASSERT_LE(stats->f_bfree, stats->f_blocks); - ASSERT_LE(stats->f_bavail, stats->f_bfree); + ASSERT(stats->f_bsize > 0); + ASSERT(stats->f_blocks > 0); + ASSERT(stats->f_bfree <= stats->f_blocks); + ASSERT(stats->f_bavail <= stats->f_bfree); #ifdef _WIN32 - ASSERT_OK(stats->f_files); - ASSERT_OK(stats->f_ffree); + ASSERT(stats->f_files == 0); + ASSERT(stats->f_ffree == 0); #else /* There is no assertion for stats->f_files that makes sense, so ignore it. */ - ASSERT_LE(stats->f_ffree, stats->f_files); + ASSERT(stats->f_ffree <= stats->f_files); #endif uv_fs_req_cleanup(req); ASSERT_NULL(req->ptr); @@ -369,27 +319,27 @@ static void statfs_cb(uv_fs_t* req) { static void close_cb(uv_fs_t* req) { int r; - ASSERT_PTR_EQ(req, &close_req); - ASSERT_EQ(req->fs_type, UV_FS_CLOSE); - ASSERT_OK(req->result); + ASSERT(req == &close_req); + ASSERT(req->fs_type == UV_FS_CLOSE); + ASSERT(req->result == 0); close_cb_count++; uv_fs_req_cleanup(req); if (close_cb_count == 3) { r = uv_fs_unlink(loop, &unlink_req, "test_file2", unlink_cb); - ASSERT_OK(r); + ASSERT(r == 0); } } static void ftruncate_cb(uv_fs_t* req) { int r; - ASSERT_PTR_EQ(req, &ftruncate_req); - ASSERT_EQ(req->fs_type, UV_FS_FTRUNCATE); - ASSERT_OK(req->result); + ASSERT(req == &ftruncate_req); + ASSERT(req->fs_type == UV_FS_FTRUNCATE); + ASSERT(req->result == 0); ftruncate_cb_count++; uv_fs_req_cleanup(req); r = uv_fs_close(loop, &close_req, open_req1.result, close_cb); - ASSERT_OK(r); + ASSERT(r == 0); } static void fail_cb(uv_fs_t* req) { @@ -398,45 +348,45 @@ static void fail_cb(uv_fs_t* req) { static void read_cb(uv_fs_t* req) { int r; - ASSERT_PTR_EQ(req, &read_req); - ASSERT_EQ(req->fs_type, UV_FS_READ); - ASSERT_GE(req->result, 0); /* FIXME(bnoordhuis) Check if requested size? */ + ASSERT(req == &read_req); + ASSERT(req->fs_type == UV_FS_READ); + ASSERT(req->result >= 0); /* FIXME(bnoordhuis) Check if requested size? */ read_cb_count++; uv_fs_req_cleanup(req); if (read_cb_count == 1) { - ASSERT_OK(strcmp(buf, test_buf)); + ASSERT(strcmp(buf, test_buf) == 0); r = uv_fs_ftruncate(loop, &ftruncate_req, open_req1.result, 7, ftruncate_cb); } else { - ASSERT_OK(strcmp(buf, "test-bu")); + ASSERT(strcmp(buf, "test-bu") == 0); r = uv_fs_close(loop, &close_req, open_req1.result, close_cb); } - ASSERT_OK(r); + ASSERT(r == 0); } static void open_cb(uv_fs_t* req) { int r; - ASSERT_PTR_EQ(req, &open_req1); - ASSERT_EQ(req->fs_type, UV_FS_OPEN); + ASSERT(req == &open_req1); + ASSERT(req->fs_type == UV_FS_OPEN); if (req->result < 0) { fprintf(stderr, "async open error: %d\n", (int) req->result); ASSERT(0); } open_cb_count++; ASSERT(req->path); - ASSERT_OK(memcmp(req->path, "test_file2\0", 11)); + ASSERT(memcmp(req->path, "test_file2\0", 11) == 0); uv_fs_req_cleanup(req); memset(buf, 0, sizeof(buf)); iov = uv_buf_init(buf, sizeof(buf)); r = uv_fs_read(loop, &read_req, open_req1.result, &iov, 1, -1, read_cb); - ASSERT_OK(r); + ASSERT(r == 0); } static void open_cb_simple(uv_fs_t* req) { - ASSERT_EQ(req->fs_type, UV_FS_OPEN); + ASSERT(req->fs_type == UV_FS_OPEN); if (req->result < 0) { fprintf(stderr, "async open error: %d\n", (int) req->result); ASSERT(0); @@ -449,69 +399,69 @@ static void open_cb_simple(uv_fs_t* req) { static void fsync_cb(uv_fs_t* req) { int r; - ASSERT_PTR_EQ(req, &fsync_req); - ASSERT_EQ(req->fs_type, UV_FS_FSYNC); - ASSERT_OK(req->result); + ASSERT(req == &fsync_req); + ASSERT(req->fs_type == UV_FS_FSYNC); + ASSERT(req->result == 0); fsync_cb_count++; uv_fs_req_cleanup(req); r = uv_fs_close(loop, &close_req, open_req1.result, close_cb); - ASSERT_OK(r); + ASSERT(r == 0); } static void fdatasync_cb(uv_fs_t* req) { int r; - ASSERT_PTR_EQ(req, &fdatasync_req); - ASSERT_EQ(req->fs_type, UV_FS_FDATASYNC); - ASSERT_OK(req->result); + ASSERT(req == &fdatasync_req); + ASSERT(req->fs_type == UV_FS_FDATASYNC); + ASSERT(req->result == 0); fdatasync_cb_count++; uv_fs_req_cleanup(req); r = uv_fs_fsync(loop, &fsync_req, open_req1.result, fsync_cb); - ASSERT_OK(r); + ASSERT(r == 0); } static void write_cb(uv_fs_t* req) { int r; - ASSERT_PTR_EQ(req, &write_req); - ASSERT_EQ(req->fs_type, UV_FS_WRITE); - ASSERT_GE(req->result, 0); /* FIXME(bnoordhuis) Check if requested size? */ + ASSERT(req == &write_req); + ASSERT(req->fs_type == UV_FS_WRITE); + ASSERT(req->result >= 0); /* FIXME(bnoordhuis) Check if requested size? */ write_cb_count++; uv_fs_req_cleanup(req); r = uv_fs_fdatasync(loop, &fdatasync_req, open_req1.result, fdatasync_cb); - ASSERT_OK(r); + ASSERT(r == 0); } static void create_cb(uv_fs_t* req) { int r; - ASSERT_PTR_EQ(req, &open_req1); - ASSERT_EQ(req->fs_type, UV_FS_OPEN); - ASSERT_GE(req->result, 0); + ASSERT(req == &open_req1); + ASSERT(req->fs_type == UV_FS_OPEN); + ASSERT(req->result >= 0); create_cb_count++; uv_fs_req_cleanup(req); iov = uv_buf_init(test_buf, sizeof(test_buf)); r = uv_fs_write(loop, &write_req, req->result, &iov, 1, -1, write_cb); - ASSERT_OK(r); + ASSERT(r == 0); } static void rename_cb(uv_fs_t* req) { - ASSERT_PTR_EQ(req, &rename_req); - ASSERT_EQ(req->fs_type, UV_FS_RENAME); - ASSERT_OK(req->result); + ASSERT(req == &rename_req); + ASSERT(req->fs_type == UV_FS_RENAME); + ASSERT(req->result == 0); rename_cb_count++; uv_fs_req_cleanup(req); } static void mkdir_cb(uv_fs_t* req) { - ASSERT_PTR_EQ(req, &mkdir_req); - ASSERT_EQ(req->fs_type, UV_FS_MKDIR); - ASSERT_OK(req->result); + ASSERT(req == &mkdir_req); + ASSERT(req->fs_type == UV_FS_MKDIR); + ASSERT(req->result == 0); mkdir_cb_count++; ASSERT(req->path); - ASSERT_OK(memcmp(req->path, "test_dir\0", 9)); + ASSERT(memcmp(req->path, "test_dir\0", 9) == 0); uv_fs_req_cleanup(req); } @@ -519,24 +469,24 @@ static void mkdir_cb(uv_fs_t* req) { static void check_mkdtemp_result(uv_fs_t* req) { int r; - ASSERT_EQ(req->fs_type, UV_FS_MKDTEMP); - ASSERT_OK(req->result); + ASSERT(req->fs_type == UV_FS_MKDTEMP); + ASSERT(req->result == 0); ASSERT(req->path); - ASSERT_EQ(15, strlen(req->path)); - ASSERT_OK(memcmp(req->path, "test_dir_", 9)); - ASSERT_NE(0, memcmp(req->path + 9, "XXXXXX", 6)); + ASSERT(strlen(req->path) == 15); + ASSERT(memcmp(req->path, "test_dir_", 9) == 0); + ASSERT(memcmp(req->path + 9, "XXXXXX", 6) != 0); check_permission(req->path, 0700); /* Check if req->path is actually a directory */ r = uv_fs_stat(NULL, &stat_req, req->path, NULL); - ASSERT_OK(r); + ASSERT(r == 0); ASSERT(((uv_stat_t*)stat_req.ptr)->st_mode & S_IFDIR); uv_fs_req_cleanup(&stat_req); } static void mkdtemp_cb(uv_fs_t* req) { - ASSERT_PTR_EQ(req, &mkdtemp_req1); + ASSERT(req == &mkdtemp_req1); check_mkdtemp_result(req); mkdtemp_cb_count++; } @@ -545,36 +495,36 @@ static void mkdtemp_cb(uv_fs_t* req) { static void check_mkstemp_result(uv_fs_t* req) { int r; - ASSERT_EQ(req->fs_type, UV_FS_MKSTEMP); - ASSERT_GE(req->result, 0); + ASSERT(req->fs_type == UV_FS_MKSTEMP); + ASSERT(req->result >= 0); ASSERT(req->path); - ASSERT_EQ(16, strlen(req->path)); - ASSERT_OK(memcmp(req->path, "test_file_", 10)); - ASSERT_NE(0, memcmp(req->path + 10, "XXXXXX", 6)); + ASSERT(strlen(req->path) == 16); + ASSERT(memcmp(req->path, "test_file_", 10) == 0); + ASSERT(memcmp(req->path + 10, "XXXXXX", 6) != 0); check_permission(req->path, 0600); /* Check if req->path is actually a file */ r = uv_fs_stat(NULL, &stat_req, req->path, NULL); - ASSERT_OK(r); + ASSERT(r == 0); ASSERT(stat_req.statbuf.st_mode & S_IFREG); uv_fs_req_cleanup(&stat_req); } static void mkstemp_cb(uv_fs_t* req) { - ASSERT_PTR_EQ(req, &mkstemp_req1); + ASSERT(req == &mkstemp_req1); check_mkstemp_result(req); mkstemp_cb_count++; } static void rmdir_cb(uv_fs_t* req) { - ASSERT_PTR_EQ(req, &rmdir_req); - ASSERT_EQ(req->fs_type, UV_FS_RMDIR); - ASSERT_OK(req->result); + ASSERT(req == &rmdir_req); + ASSERT(req->fs_type == UV_FS_RMDIR); + ASSERT(req->result == 0); rmdir_cb_count++; ASSERT(req->path); - ASSERT_OK(memcmp(req->path, "test_dir\0", 9)); + ASSERT(memcmp(req->path, "test_dir\0", 9) == 0); uv_fs_req_cleanup(req); } @@ -591,21 +541,21 @@ static void assert_is_file_type(uv_dirent_t dent) { * https://github.com/libuv/libuv/issues/501 */ #if defined(__APPLE__) || defined(_WIN32) - ASSERT_EQ(dent.type, UV_DIRENT_FILE); + ASSERT(dent.type == UV_DIRENT_FILE); #else ASSERT(dent.type == UV_DIRENT_FILE || dent.type == UV_DIRENT_UNKNOWN); #endif #else - ASSERT_EQ(dent.type, UV_DIRENT_UNKNOWN); + ASSERT(dent.type == UV_DIRENT_UNKNOWN); #endif } static void scandir_cb(uv_fs_t* req) { uv_dirent_t dent; - ASSERT_PTR_EQ(req, &scandir_req); - ASSERT_EQ(req->fs_type, UV_FS_SCANDIR); - ASSERT_EQ(2, req->result); + ASSERT(req == &scandir_req); + ASSERT(req->fs_type == UV_FS_SCANDIR); + ASSERT(req->result == 2); ASSERT(req->ptr); while (UV_EOF != uv_fs_scandir_next(req, &dent)) { @@ -614,7 +564,7 @@ static void scandir_cb(uv_fs_t* req) { } scandir_cb_count++; ASSERT(req->path); - ASSERT_OK(memcmp(req->path, "test_dir\0", 9)); + ASSERT(memcmp(req->path, "test_dir\0", 9) == 0); uv_fs_req_cleanup(req); ASSERT(!req->ptr); } @@ -623,11 +573,11 @@ static void scandir_cb(uv_fs_t* req) { static void empty_scandir_cb(uv_fs_t* req) { uv_dirent_t dent; - ASSERT_PTR_EQ(req, &scandir_req); - ASSERT_EQ(req->fs_type, UV_FS_SCANDIR); - ASSERT_OK(req->result); + ASSERT(req == &scandir_req); + ASSERT(req->fs_type == UV_FS_SCANDIR); + ASSERT(req->result == 0); ASSERT_NULL(req->ptr); - ASSERT_EQ(UV_EOF, uv_fs_scandir_next(req, &dent)); + ASSERT(UV_EOF == uv_fs_scandir_next(req, &dent)); uv_fs_req_cleanup(req); scandir_cb_count++; } @@ -635,20 +585,20 @@ static void empty_scandir_cb(uv_fs_t* req) { static void non_existent_scandir_cb(uv_fs_t* req) { uv_dirent_t dent; - ASSERT_PTR_EQ(req, &scandir_req); - ASSERT_EQ(req->fs_type, UV_FS_SCANDIR); - ASSERT_EQ(req->result, UV_ENOENT); + ASSERT(req == &scandir_req); + ASSERT(req->fs_type == UV_FS_SCANDIR); + ASSERT(req->result == UV_ENOENT); ASSERT_NULL(req->ptr); - ASSERT_EQ(UV_ENOENT, uv_fs_scandir_next(req, &dent)); + ASSERT(UV_ENOENT == uv_fs_scandir_next(req, &dent)); uv_fs_req_cleanup(req); scandir_cb_count++; } static void file_scandir_cb(uv_fs_t* req) { - ASSERT_PTR_EQ(req, &scandir_req); - ASSERT_EQ(req->fs_type, UV_FS_SCANDIR); - ASSERT_EQ(req->result, UV_ENOTDIR); + ASSERT(req == &scandir_req); + ASSERT(req->fs_type == UV_FS_SCANDIR); + ASSERT(req->result == UV_ENOTDIR); ASSERT_NULL(req->ptr); uv_fs_req_cleanup(req); scandir_cb_count++; @@ -656,18 +606,9 @@ static void file_scandir_cb(uv_fs_t* req) { static void stat_cb(uv_fs_t* req) { - ASSERT_PTR_EQ(req, &stat_req); + ASSERT(req == &stat_req); ASSERT(req->fs_type == UV_FS_STAT || req->fs_type == UV_FS_LSTAT); - ASSERT_OK(req->result); - ASSERT(req->ptr); - stat_cb_count++; - uv_fs_req_cleanup(req); - ASSERT(!req->ptr); -} - -static void stat_batch_cb(uv_fs_t* req) { - ASSERT(req->fs_type == UV_FS_STAT || req->fs_type == UV_FS_LSTAT); - ASSERT_OK(req->result); + ASSERT(req->result == 0); ASSERT(req->ptr); stat_cb_count++; uv_fs_req_cleanup(req); @@ -676,40 +617,40 @@ static void stat_batch_cb(uv_fs_t* req) { static void sendfile_cb(uv_fs_t* req) { - ASSERT_PTR_EQ(req, &sendfile_req); - ASSERT_EQ(req->fs_type, UV_FS_SENDFILE); - ASSERT_EQ(65545, req->result); + ASSERT(req == &sendfile_req); + ASSERT(req->fs_type == UV_FS_SENDFILE); + ASSERT(req->result == 65545); sendfile_cb_count++; uv_fs_req_cleanup(req); } static void sendfile_nodata_cb(uv_fs_t* req) { - ASSERT_PTR_EQ(req, &sendfile_req); - ASSERT_EQ(req->fs_type, UV_FS_SENDFILE); - ASSERT_OK(req->result); + ASSERT(req == &sendfile_req); + ASSERT(req->fs_type == UV_FS_SENDFILE); + ASSERT(req->result == 0); sendfile_cb_count++; uv_fs_req_cleanup(req); } static void open_noent_cb(uv_fs_t* req) { - ASSERT_EQ(req->fs_type, UV_FS_OPEN); - ASSERT_EQ(req->result, UV_ENOENT); + ASSERT(req->fs_type == UV_FS_OPEN); + ASSERT(req->result == UV_ENOENT); open_cb_count++; uv_fs_req_cleanup(req); } static void open_nametoolong_cb(uv_fs_t* req) { - ASSERT_EQ(req->fs_type, UV_FS_OPEN); - ASSERT_EQ(req->result, UV_ENAMETOOLONG); + ASSERT(req->fs_type == UV_FS_OPEN); + ASSERT(req->result == UV_ENAMETOOLONG); open_cb_count++; uv_fs_req_cleanup(req); } static void open_loop_cb(uv_fs_t* req) { - ASSERT_EQ(req->fs_type, UV_FS_OPEN); - ASSERT_EQ(req->result, UV_ELOOP); + ASSERT(req->fs_type == UV_FS_OPEN); + ASSERT(req->result == UV_ELOOP); open_cb_count++; uv_fs_req_cleanup(req); } @@ -721,22 +662,21 @@ TEST_IMPL(fs_file_noent) { loop = uv_default_loop(); - r = uv_fs_open(NULL, &req, "does_not_exist", UV_FS_O_RDONLY, 0, NULL); - ASSERT_EQ(r, UV_ENOENT); - ASSERT_EQ(req.result, UV_ENOENT); + r = uv_fs_open(NULL, &req, "does_not_exist", O_RDONLY, 0, NULL); + ASSERT(r == UV_ENOENT); + ASSERT(req.result == UV_ENOENT); uv_fs_req_cleanup(&req); - r = uv_fs_open(loop, &req, "does_not_exist", UV_FS_O_RDONLY, 0, - open_noent_cb); - ASSERT_OK(r); + r = uv_fs_open(loop, &req, "does_not_exist", O_RDONLY, 0, open_noent_cb); + ASSERT(r == 0); - ASSERT_OK(open_cb_count); + ASSERT(open_cb_count == 0); uv_run(loop, UV_RUN_DEFAULT); - ASSERT_EQ(1, open_cb_count); + ASSERT(open_cb_count == 1); /* TODO add EACCES test */ - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -750,19 +690,19 @@ TEST_IMPL(fs_file_nametoolong) { memset(name, 'a', TOO_LONG_NAME_LENGTH); name[TOO_LONG_NAME_LENGTH] = 0; - r = uv_fs_open(NULL, &req, name, UV_FS_O_RDONLY, 0, NULL); - ASSERT_EQ(r, UV_ENAMETOOLONG); - ASSERT_EQ(req.result, UV_ENAMETOOLONG); + r = uv_fs_open(NULL, &req, name, O_RDONLY, 0, NULL); + ASSERT(r == UV_ENAMETOOLONG); + ASSERT(req.result == UV_ENAMETOOLONG); uv_fs_req_cleanup(&req); - r = uv_fs_open(loop, &req, name, UV_FS_O_RDONLY, 0, open_nametoolong_cb); - ASSERT_OK(r); + r = uv_fs_open(loop, &req, name, O_RDONLY, 0, open_nametoolong_cb); + ASSERT(r == 0); - ASSERT_OK(open_cb_count); + ASSERT(open_cb_count == 0); uv_run(loop, UV_RUN_DEFAULT); - ASSERT_EQ(1, open_cb_count); + ASSERT(open_cb_count == 1); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -776,10 +716,11 @@ TEST_IMPL(fs_file_loop) { r = uv_fs_symlink(NULL, &req, "test_symlink", "test_symlink", 0, NULL); #ifdef _WIN32 /* - * Symlinks are only suported but only when elevated, otherwise + * Windows XP and Server 2003 don't support symlinks; we'll get UV_ENOTSUP. + * Starting with vista they are supported, but only when elevated, otherwise * we'll see UV_EPERM. */ - if (r == UV_EPERM) + if (r == UV_ENOTSUP || r == UV_EPERM) return 0; #elif defined(__MSYS__) /* MSYS2's approximation of symlinks with copies does not work for broken @@ -787,24 +728,24 @@ TEST_IMPL(fs_file_loop) { if (r == UV_ENOENT) return 0; #endif - ASSERT_OK(r); + ASSERT(r == 0); uv_fs_req_cleanup(&req); - r = uv_fs_open(NULL, &req, "test_symlink", UV_FS_O_RDONLY, 0, NULL); - ASSERT_EQ(r, UV_ELOOP); - ASSERT_EQ(req.result, UV_ELOOP); + r = uv_fs_open(NULL, &req, "test_symlink", O_RDONLY, 0, NULL); + ASSERT(r == UV_ELOOP); + ASSERT(req.result == UV_ELOOP); uv_fs_req_cleanup(&req); - r = uv_fs_open(loop, &req, "test_symlink", UV_FS_O_RDONLY, 0, open_loop_cb); - ASSERT_OK(r); + r = uv_fs_open(loop, &req, "test_symlink", O_RDONLY, 0, open_loop_cb); + ASSERT(r == 0); - ASSERT_OK(open_cb_count); + ASSERT(open_cb_count == 0); uv_run(loop, UV_RUN_DEFAULT); - ASSERT_EQ(1, open_cb_count); + ASSERT(open_cb_count == 1); unlink("test_symlink"); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -821,9 +762,9 @@ static void check_utime(const char* path, else r = uv_fs_stat(loop, &req, path, NULL); - ASSERT_OK(r); + ASSERT_EQ(r, 0); - ASSERT_OK(req.result); + ASSERT_EQ(req.result, 0); s = &req.statbuf; if (s->st_atim.tv_nsec == 0 && s->st_mtim.tv_nsec == 0) { @@ -872,9 +813,9 @@ static void check_utime(const char* path, static void utime_cb(uv_fs_t* req) { utime_check_t* c; - ASSERT_PTR_EQ(req, &utime_req); - ASSERT_OK(req->result); - ASSERT_EQ(req->fs_type, UV_FS_UTIME); + ASSERT(req == &utime_req); + ASSERT(req->result == 0); + ASSERT(req->fs_type == UV_FS_UTIME); c = req->data; check_utime(c->path, c->atime, c->mtime, /* test_lutime */ 0); @@ -887,9 +828,9 @@ static void utime_cb(uv_fs_t* req) { static void futime_cb(uv_fs_t* req) { utime_check_t* c; - ASSERT_PTR_EQ(req, &futime_req); - ASSERT_OK(req->result); - ASSERT_EQ(req->fs_type, UV_FS_FUTIME); + ASSERT(req == &futime_req); + ASSERT(req->result == 0); + ASSERT(req->fs_type == UV_FS_FUTIME); c = req->data; check_utime(c->path, c->atime, c->mtime, /* test_lutime */ 0); @@ -902,8 +843,8 @@ static void futime_cb(uv_fs_t* req) { static void lutime_cb(uv_fs_t* req) { utime_check_t* c; - ASSERT_OK(req->result); - ASSERT_EQ(req->fs_type, UV_FS_LUTIME); + ASSERT(req->result == 0); + ASSERT(req->fs_type == UV_FS_LUTIME); c = req->data; check_utime(c->path, c->atime, c->mtime, /* test_lutime */ 1); @@ -922,56 +863,56 @@ TEST_IMPL(fs_file_async) { loop = uv_default_loop(); - r = uv_fs_open(loop, &open_req1, "test_file", UV_FS_O_WRONLY | UV_FS_O_CREAT, + r = uv_fs_open(loop, &open_req1, "test_file", O_WRONLY | O_CREAT, S_IRUSR | S_IWUSR, create_cb); - ASSERT_OK(r); + ASSERT(r == 0); uv_run(loop, UV_RUN_DEFAULT); - ASSERT_EQ(1, create_cb_count); - ASSERT_EQ(1, write_cb_count); - ASSERT_EQ(1, fsync_cb_count); - ASSERT_EQ(1, fdatasync_cb_count); - ASSERT_EQ(1, close_cb_count); + ASSERT(create_cb_count == 1); + ASSERT(write_cb_count == 1); + ASSERT(fsync_cb_count == 1); + ASSERT(fdatasync_cb_count == 1); + ASSERT(close_cb_count == 1); r = uv_fs_rename(loop, &rename_req, "test_file", "test_file2", rename_cb); - ASSERT_OK(r); + ASSERT(r == 0); uv_run(loop, UV_RUN_DEFAULT); - ASSERT_EQ(1, create_cb_count); - ASSERT_EQ(1, write_cb_count); - ASSERT_EQ(1, close_cb_count); - ASSERT_EQ(1, rename_cb_count); + ASSERT(create_cb_count == 1); + ASSERT(write_cb_count == 1); + ASSERT(close_cb_count == 1); + ASSERT(rename_cb_count == 1); - r = uv_fs_open(loop, &open_req1, "test_file2", UV_FS_O_RDWR, 0, open_cb); - ASSERT_OK(r); + r = uv_fs_open(loop, &open_req1, "test_file2", O_RDWR, 0, open_cb); + ASSERT(r == 0); uv_run(loop, UV_RUN_DEFAULT); - ASSERT_EQ(1, open_cb_count); - ASSERT_EQ(1, read_cb_count); - ASSERT_EQ(2, close_cb_count); - ASSERT_EQ(1, rename_cb_count); - ASSERT_EQ(1, create_cb_count); - ASSERT_EQ(1, write_cb_count); - ASSERT_EQ(1, ftruncate_cb_count); + ASSERT(open_cb_count == 1); + ASSERT(read_cb_count == 1); + ASSERT(close_cb_count == 2); + ASSERT(rename_cb_count == 1); + ASSERT(create_cb_count == 1); + ASSERT(write_cb_count == 1); + ASSERT(ftruncate_cb_count == 1); - r = uv_fs_open(loop, &open_req1, "test_file2", UV_FS_O_RDONLY, 0, open_cb); - ASSERT_OK(r); + r = uv_fs_open(loop, &open_req1, "test_file2", O_RDONLY, 0, open_cb); + ASSERT(r == 0); uv_run(loop, UV_RUN_DEFAULT); - ASSERT_EQ(2, open_cb_count); - ASSERT_EQ(2, read_cb_count); - ASSERT_EQ(3, close_cb_count); - ASSERT_EQ(1, rename_cb_count); - ASSERT_EQ(1, unlink_cb_count); - ASSERT_EQ(1, create_cb_count); - ASSERT_EQ(1, write_cb_count); - ASSERT_EQ(1, ftruncate_cb_count); + ASSERT(open_cb_count == 2); + ASSERT(read_cb_count == 2); + ASSERT(close_cb_count == 3); + ASSERT(rename_cb_count == 1); + ASSERT(unlink_cb_count == 1); + ASSERT(create_cb_count == 1); + ASSERT(write_cb_count == 1); + ASSERT(ftruncate_cb_count == 1); /* Cleanup. */ unlink("test_file"); unlink("test_file2"); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -986,73 +927,71 @@ static void fs_file_sync(int add_flags) { loop = uv_default_loop(); r = uv_fs_open(loop, &open_req1, "test_file", - UV_FS_O_WRONLY | UV_FS_O_CREAT | add_flags, S_IWUSR | S_IRUSR, - NULL); - ASSERT_GE(r, 0); - ASSERT_GE(open_req1.result, 0); + O_WRONLY | O_CREAT | add_flags, S_IWUSR | S_IRUSR, NULL); + ASSERT(r >= 0); + ASSERT(open_req1.result >= 0); uv_fs_req_cleanup(&open_req1); iov = uv_buf_init(test_buf, sizeof(test_buf)); r = uv_fs_write(NULL, &write_req, open_req1.result, &iov, 1, -1, NULL); - ASSERT_GE(r, 0); - ASSERT_GE(write_req.result, 0); + ASSERT(r >= 0); + ASSERT(write_req.result >= 0); uv_fs_req_cleanup(&write_req); r = uv_fs_close(NULL, &close_req, open_req1.result, NULL); - ASSERT_OK(r); - ASSERT_OK(close_req.result); + ASSERT(r == 0); + ASSERT(close_req.result == 0); uv_fs_req_cleanup(&close_req); - r = uv_fs_open(NULL, &open_req1, "test_file", UV_FS_O_RDWR | add_flags, 0, - NULL); - ASSERT_GE(r, 0); - ASSERT_GE(open_req1.result, 0); + r = uv_fs_open(NULL, &open_req1, "test_file", O_RDWR | add_flags, 0, NULL); + ASSERT(r >= 0); + ASSERT(open_req1.result >= 0); uv_fs_req_cleanup(&open_req1); iov = uv_buf_init(buf, sizeof(buf)); r = uv_fs_read(NULL, &read_req, open_req1.result, &iov, 1, -1, NULL); - ASSERT_GE(r, 0); - ASSERT_GE(read_req.result, 0); - ASSERT_OK(strcmp(buf, test_buf)); + ASSERT(r >= 0); + ASSERT(read_req.result >= 0); + ASSERT(strcmp(buf, test_buf) == 0); uv_fs_req_cleanup(&read_req); r = uv_fs_ftruncate(NULL, &ftruncate_req, open_req1.result, 7, NULL); - ASSERT_OK(r); - ASSERT_OK(ftruncate_req.result); + ASSERT(r == 0); + ASSERT(ftruncate_req.result == 0); uv_fs_req_cleanup(&ftruncate_req); r = uv_fs_close(NULL, &close_req, open_req1.result, NULL); - ASSERT_OK(r); - ASSERT_OK(close_req.result); + ASSERT(r == 0); + ASSERT(close_req.result == 0); uv_fs_req_cleanup(&close_req); r = uv_fs_rename(NULL, &rename_req, "test_file", "test_file2", NULL); - ASSERT_OK(r); - ASSERT_OK(rename_req.result); + ASSERT(r == 0); + ASSERT(rename_req.result == 0); uv_fs_req_cleanup(&rename_req); - r = uv_fs_open(NULL, &open_req1, "test_file2", UV_FS_O_RDONLY | add_flags, 0, + r = uv_fs_open(NULL, &open_req1, "test_file2", O_RDONLY | add_flags, 0, NULL); - ASSERT_GE(r, 0); - ASSERT_GE(open_req1.result, 0); + ASSERT(r >= 0); + ASSERT(open_req1.result >= 0); uv_fs_req_cleanup(&open_req1); memset(buf, 0, sizeof(buf)); iov = uv_buf_init(buf, sizeof(buf)); r = uv_fs_read(NULL, &read_req, open_req1.result, &iov, 1, -1, NULL); - ASSERT_GE(r, 0); - ASSERT_GE(read_req.result, 0); - ASSERT_OK(strcmp(buf, "test-bu")); + ASSERT(r >= 0); + ASSERT(read_req.result >= 0); + ASSERT(strcmp(buf, "test-bu") == 0); uv_fs_req_cleanup(&read_req); r = uv_fs_close(NULL, &close_req, open_req1.result, NULL); - ASSERT_OK(r); - ASSERT_OK(close_req.result); + ASSERT(r == 0); + ASSERT(close_req.result == 0); uv_fs_req_cleanup(&close_req); r = uv_fs_unlink(NULL, &unlink_req, "test_file2", NULL); - ASSERT_OK(r); - ASSERT_OK(unlink_req.result); + ASSERT(r == 0); + ASSERT(unlink_req.result == 0); uv_fs_req_cleanup(&unlink_req); /* Cleanup */ @@ -1063,7 +1002,7 @@ TEST_IMPL(fs_file_sync) { fs_file_sync(0); fs_file_sync(UV_FS_O_FILEMAP); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -1077,21 +1016,20 @@ static void fs_file_write_null_buffer(int add_flags) { loop = uv_default_loop(); r = uv_fs_open(NULL, &open_req1, "test_file", - UV_FS_O_WRONLY | UV_FS_O_CREAT | add_flags, S_IWUSR | S_IRUSR, - NULL); - ASSERT_GE(r, 0); - ASSERT_GE(open_req1.result, 0); + O_WRONLY | O_CREAT | add_flags, S_IWUSR | S_IRUSR, NULL); + ASSERT(r >= 0); + ASSERT(open_req1.result >= 0); uv_fs_req_cleanup(&open_req1); iov = uv_buf_init(NULL, 0); r = uv_fs_write(NULL, &write_req, open_req1.result, &iov, 1, -1, NULL); - ASSERT_OK(r); - ASSERT_OK(write_req.result); + ASSERT(r == 0); + ASSERT(write_req.result == 0); uv_fs_req_cleanup(&write_req); r = uv_fs_close(NULL, &close_req, open_req1.result, NULL); - ASSERT_OK(r); - ASSERT_OK(close_req.result); + ASSERT(r == 0); + ASSERT(close_req.result == 0); uv_fs_req_cleanup(&close_req); unlink("test_file"); @@ -1100,7 +1038,7 @@ TEST_IMPL(fs_file_write_null_buffer) { fs_file_write_null_buffer(0); fs_file_write_null_buffer(UV_FS_O_FILEMAP); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -1117,40 +1055,38 @@ TEST_IMPL(fs_async_dir) { loop = uv_default_loop(); r = uv_fs_mkdir(loop, &mkdir_req, "test_dir", 0755, mkdir_cb); - ASSERT_OK(r); + ASSERT(r == 0); uv_run(loop, UV_RUN_DEFAULT); - ASSERT_EQ(1, mkdir_cb_count); + ASSERT(mkdir_cb_count == 1); /* Create 2 files synchronously. */ - r = uv_fs_open(NULL, &open_req1, "test_dir/file1", - UV_FS_O_WRONLY | UV_FS_O_CREAT, + r = uv_fs_open(NULL, &open_req1, "test_dir/file1", O_WRONLY | O_CREAT, S_IWUSR | S_IRUSR, NULL); - ASSERT_GE(r, 0); + ASSERT(r >= 0); uv_fs_req_cleanup(&open_req1); r = uv_fs_close(NULL, &close_req, open_req1.result, NULL); - ASSERT_OK(r); + ASSERT(r == 0); uv_fs_req_cleanup(&close_req); - r = uv_fs_open(NULL, &open_req1, "test_dir/file2", - UV_FS_O_WRONLY | UV_FS_O_CREAT, + r = uv_fs_open(NULL, &open_req1, "test_dir/file2", O_WRONLY | O_CREAT, S_IWUSR | S_IRUSR, NULL); - ASSERT_GE(r, 0); + ASSERT(r >= 0); uv_fs_req_cleanup(&open_req1); r = uv_fs_close(NULL, &close_req, open_req1.result, NULL); - ASSERT_OK(r); + ASSERT(r == 0); uv_fs_req_cleanup(&close_req); r = uv_fs_scandir(loop, &scandir_req, "test_dir", 0, scandir_cb); - ASSERT_OK(r); + ASSERT(r == 0); uv_run(loop, UV_RUN_DEFAULT); - ASSERT_EQ(1, scandir_cb_count); + ASSERT(scandir_cb_count == 1); /* sync uv_fs_scandir */ r = uv_fs_scandir(NULL, &scandir_req, "test_dir", 0, NULL); - ASSERT_EQ(2, r); - ASSERT_EQ(2, scandir_req.result); + ASSERT(r == 2); + ASSERT(scandir_req.result == 2); ASSERT(scandir_req.ptr); while (UV_EOF != uv_fs_scandir_next(&scandir_req, &dent)) { ASSERT(strcmp(dent.name, "file1") == 0 || strcmp(dent.name, "file2") == 0); @@ -1160,49 +1096,49 @@ TEST_IMPL(fs_async_dir) { ASSERT(!scandir_req.ptr); r = uv_fs_stat(loop, &stat_req, "test_dir", stat_cb); - ASSERT_OK(r); + ASSERT(r == 0); uv_run(loop, UV_RUN_DEFAULT); r = uv_fs_stat(loop, &stat_req, "test_dir/", stat_cb); - ASSERT_OK(r); + ASSERT(r == 0); uv_run(loop, UV_RUN_DEFAULT); r = uv_fs_lstat(loop, &stat_req, "test_dir", stat_cb); - ASSERT_OK(r); + ASSERT(r == 0); uv_run(loop, UV_RUN_DEFAULT); r = uv_fs_lstat(loop, &stat_req, "test_dir/", stat_cb); - ASSERT_OK(r); + ASSERT(r == 0); uv_run(loop, UV_RUN_DEFAULT); - ASSERT_EQ(4, stat_cb_count); + ASSERT(stat_cb_count == 4); r = uv_fs_unlink(loop, &unlink_req, "test_dir/file1", unlink_cb); - ASSERT_OK(r); + ASSERT(r == 0); uv_run(loop, UV_RUN_DEFAULT); - ASSERT_EQ(1, unlink_cb_count); + ASSERT(unlink_cb_count == 1); r = uv_fs_unlink(loop, &unlink_req, "test_dir/file2", unlink_cb); - ASSERT_OK(r); + ASSERT(r == 0); uv_run(loop, UV_RUN_DEFAULT); - ASSERT_EQ(2, unlink_cb_count); + ASSERT(unlink_cb_count == 2); r = uv_fs_rmdir(loop, &rmdir_req, "test_dir", rmdir_cb); - ASSERT_OK(r); + ASSERT(r == 0); uv_run(loop, UV_RUN_DEFAULT); - ASSERT_EQ(1, rmdir_cb_count); + ASSERT(rmdir_cb_count == 1); /* Cleanup */ unlink("test_dir/file1"); unlink("test_dir/file2"); rmdir("test_dir"); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } -static int test_sendfile(void (*setup)(int), uv_fs_cb cb, size_t expected_size) { +static int test_sendfile(void (*setup)(int), uv_fs_cb cb, off_t expected_size) { int f, r; struct stat s1, s2; uv_fs_t req; @@ -1214,59 +1150,57 @@ static int test_sendfile(void (*setup)(int), uv_fs_cb cb, size_t expected_size) unlink("test_file"); unlink("test_file2"); - f = open("test_file", UV_FS_O_WRONLY | UV_FS_O_CREAT, S_IWUSR | S_IRUSR); - ASSERT_NE(f, -1); + f = open("test_file", O_WRONLY | O_CREAT, S_IWUSR | S_IRUSR); + ASSERT(f != -1); if (setup != NULL) setup(f); r = close(f); - ASSERT_OK(r); + ASSERT(r == 0); /* Test starts here. */ - r = uv_fs_open(NULL, &open_req1, "test_file", UV_FS_O_RDWR, 0, NULL); - ASSERT_GE(r, 0); - ASSERT_GE(open_req1.result, 0); + r = uv_fs_open(NULL, &open_req1, "test_file", O_RDWR, 0, NULL); + ASSERT(r >= 0); + ASSERT(open_req1.result >= 0); uv_fs_req_cleanup(&open_req1); - r = uv_fs_open(NULL, &open_req2, "test_file2", UV_FS_O_WRONLY | UV_FS_O_CREAT, + r = uv_fs_open(NULL, &open_req2, "test_file2", O_WRONLY | O_CREAT, S_IWUSR | S_IRUSR, NULL); - ASSERT_GE(r, 0); - ASSERT_GE(open_req2.result, 0); + ASSERT(r >= 0); + ASSERT(open_req2.result >= 0); uv_fs_req_cleanup(&open_req2); r = uv_fs_sendfile(loop, &sendfile_req, open_req2.result, open_req1.result, 1, 131072, cb); - ASSERT_OK(r); + ASSERT(r == 0); uv_run(loop, UV_RUN_DEFAULT); - ASSERT_EQ(1, sendfile_cb_count); + ASSERT(sendfile_cb_count == 1); r = uv_fs_close(NULL, &close_req, open_req1.result, NULL); - ASSERT_OK(r); + ASSERT(r == 0); uv_fs_req_cleanup(&close_req); r = uv_fs_close(NULL, &close_req, open_req2.result, NULL); - ASSERT_OK(r); + ASSERT(r == 0); uv_fs_req_cleanup(&close_req); - memset(&s1, 0, sizeof(s1)); - memset(&s2, 0, sizeof(s2)); - ASSERT_OK(stat("test_file", &s1)); - ASSERT_OK(stat("test_file2", &s2)); - ASSERT_EQ(s2.st_size, expected_size); + ASSERT(0 == stat("test_file", &s1)); + ASSERT(0 == stat("test_file2", &s2)); + ASSERT(s2.st_size == expected_size); if (expected_size > 0) { ASSERT_UINT64_EQ(s1.st_size, s2.st_size + 1); - r = uv_fs_open(NULL, &open_req1, "test_file2", UV_FS_O_RDWR, 0, NULL); - ASSERT_GE(r, 0); - ASSERT_GE(open_req1.result, 0); + r = uv_fs_open(NULL, &open_req1, "test_file2", O_RDWR, 0, NULL); + ASSERT(r >= 0); + ASSERT(open_req1.result >= 0); uv_fs_req_cleanup(&open_req1); memset(buf1, 0, sizeof(buf1)); iov = uv_buf_init(buf1, sizeof(buf1)); r = uv_fs_read(NULL, &req, open_req1.result, &iov, 1, -1, NULL); - ASSERT_GE(r, 0); - ASSERT_GE(req.result, 0); + ASSERT(r >= 0); + ASSERT(req.result >= 0); ASSERT_EQ(buf1[0], 'e'); /* 'e' from begin */ uv_fs_req_cleanup(&req); } else { @@ -1277,15 +1211,15 @@ static int test_sendfile(void (*setup)(int), uv_fs_cb cb, size_t expected_size) unlink("test_file"); unlink("test_file2"); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } static void sendfile_setup(int f) { - ASSERT_EQ(6, write(f, "begin\n", 6)); - ASSERT_EQ(65542, lseek(f, 65536, SEEK_CUR)); - ASSERT_EQ(4, write(f, "end\n", 4)); + ASSERT(6 == write(f, "begin\n", 6)); + ASSERT(65542 == lseek(f, 65536, SEEK_CUR)); + ASSERT(4 == write(f, "end\n", 4)); } @@ -1306,18 +1240,18 @@ TEST_IMPL(fs_mkdtemp) { loop = uv_default_loop(); r = uv_fs_mkdtemp(loop, &mkdtemp_req1, path_template, mkdtemp_cb); - ASSERT_OK(r); + ASSERT(r == 0); uv_run(loop, UV_RUN_DEFAULT); - ASSERT_EQ(1, mkdtemp_cb_count); + ASSERT(mkdtemp_cb_count == 1); /* sync mkdtemp */ r = uv_fs_mkdtemp(NULL, &mkdtemp_req2, path_template, NULL); - ASSERT_OK(r); + ASSERT(r == 0); check_mkdtemp_result(&mkdtemp_req2); /* mkdtemp return different values on subsequent calls */ - ASSERT_NE(0, strcmp(mkdtemp_req1.path, mkdtemp_req2.path)); + ASSERT(strcmp(mkdtemp_req1.path, mkdtemp_req2.path) != 0); /* Cleanup */ rmdir(mkdtemp_req1.path); @@ -1325,7 +1259,7 @@ TEST_IMPL(fs_mkdtemp) { uv_fs_req_cleanup(&mkdtemp_req1); uv_fs_req_cleanup(&mkdtemp_req2); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -1339,32 +1273,30 @@ TEST_IMPL(fs_mkstemp) { loop = uv_default_loop(); r = uv_fs_mkstemp(loop, &mkstemp_req1, path_template, mkstemp_cb); - ASSERT_OK(r); + ASSERT(r == 0); uv_run(loop, UV_RUN_DEFAULT); - ASSERT_EQ(1, mkstemp_cb_count); + ASSERT(mkstemp_cb_count == 1); /* sync mkstemp */ r = uv_fs_mkstemp(NULL, &mkstemp_req2, path_template, NULL); - ASSERT_GE(r, 0); + ASSERT(r >= 0); check_mkstemp_result(&mkstemp_req2); /* mkstemp return different values on subsequent calls */ - ASSERT_NE(0, strcmp(mkstemp_req1.path, mkstemp_req2.path)); + ASSERT(strcmp(mkstemp_req1.path, mkstemp_req2.path) != 0); /* invalid template returns EINVAL */ ASSERT_EQ(UV_EINVAL, uv_fs_mkstemp(NULL, &mkstemp_req3, "test_file", NULL)); /* Make sure that path is empty string */ - ASSERT_OK(strlen(mkstemp_req3.path)); - - uv_fs_req_cleanup(&mkstemp_req3); + ASSERT_EQ(0, strlen(mkstemp_req3.path)); /* We can write to the opened file */ iov = uv_buf_init(test_buf, sizeof(test_buf)); r = uv_fs_write(NULL, &req, mkstemp_req1.result, &iov, 1, -1, NULL); - ASSERT_EQ(r, sizeof(test_buf)); - ASSERT_EQ(req.result, sizeof(test_buf)); + ASSERT(r == sizeof(test_buf)); + ASSERT(req.result == sizeof(test_buf)); uv_fs_req_cleanup(&req); /* Cleanup */ @@ -1373,16 +1305,16 @@ TEST_IMPL(fs_mkstemp) { uv_fs_close(NULL, &req, mkstemp_req2.result, NULL); uv_fs_req_cleanup(&req); - fd = uv_fs_open(NULL, &req, mkstemp_req1.path, UV_FS_O_RDONLY, 0, NULL); - ASSERT_GE(fd, 0); + fd = uv_fs_open(NULL, &req, mkstemp_req1.path , O_RDONLY, 0, NULL); + ASSERT(fd >= 0); uv_fs_req_cleanup(&req); memset(buf, 0, sizeof(buf)); iov = uv_buf_init(buf, sizeof(buf)); r = uv_fs_read(NULL, &req, fd, &iov, 1, -1, NULL); - ASSERT_GE(r, 0); - ASSERT_GE(req.result, 0); - ASSERT_OK(strcmp(buf, test_buf)); + ASSERT(r >= 0); + ASSERT(req.result >= 0); + ASSERT(strcmp(buf, test_buf) == 0); uv_fs_req_cleanup(&req); uv_fs_close(NULL, &req, fd, NULL); @@ -1393,7 +1325,7 @@ TEST_IMPL(fs_mkstemp) { uv_fs_req_cleanup(&mkstemp_req1); uv_fs_req_cleanup(&mkstemp_req2); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -1407,34 +1339,26 @@ TEST_IMPL(fs_fstat) { struct stat t; #endif -#if defined(__s390__) && defined(__QEMU__) - /* qemu-user-s390x has this weird bug where statx() reports nanoseconds - * but plain fstat() does not. - */ - RETURN_SKIP("Test does not currently work in QEMU"); -#endif - /* Setup. */ unlink("test_file"); loop = uv_default_loop(); - r = uv_fs_open(NULL, &req, "test_file", UV_FS_O_RDWR | UV_FS_O_CREAT, + r = uv_fs_open(NULL, &req, "test_file", O_RDWR | O_CREAT, S_IWUSR | S_IRUSR, NULL); - ASSERT_GE(r, 0); - ASSERT_GE(req.result, 0); + ASSERT(r >= 0); + ASSERT(req.result >= 0); file = req.result; uv_fs_req_cleanup(&req); #ifndef _WIN32 - memset(&t, 0, sizeof(t)); - ASSERT_OK(fstat(file, &t)); - ASSERT_OK(uv_fs_fstat(NULL, &req, file, NULL)); - ASSERT_OK(req.result); + ASSERT(0 == fstat(file, &t)); + ASSERT(0 == uv_fs_fstat(NULL, &req, file, NULL)); + ASSERT(req.result == 0); s = req.ptr; # if defined(__APPLE__) - ASSERT_EQ(s->st_birthtim.tv_sec, t.st_birthtimespec.tv_sec); - ASSERT_EQ(s->st_birthtim.tv_nsec, t.st_birthtimespec.tv_nsec); + ASSERT(s->st_birthtim.tv_sec == t.st_birthtimespec.tv_sec); + ASSERT(s->st_birthtim.tv_nsec == t.st_birthtimespec.tv_nsec); # elif defined(__linux__) /* If statx() is supported, the birth time should be equal to the change time * because we just created the file. On older kernels, it's set to zero. @@ -1448,53 +1372,53 @@ TEST_IMPL(fs_fstat) { iov = uv_buf_init(test_buf, sizeof(test_buf)); r = uv_fs_write(NULL, &req, file, &iov, 1, -1, NULL); - ASSERT_EQ(r, sizeof(test_buf)); - ASSERT_EQ(req.result, sizeof(test_buf)); + ASSERT(r == sizeof(test_buf)); + ASSERT(req.result == sizeof(test_buf)); uv_fs_req_cleanup(&req); memset(&req.statbuf, 0xaa, sizeof(req.statbuf)); r = uv_fs_fstat(NULL, &req, file, NULL); - ASSERT_OK(r); - ASSERT_OK(req.result); + ASSERT(r == 0); + ASSERT(req.result == 0); s = req.ptr; - ASSERT_EQ(s->st_size, sizeof(test_buf)); + ASSERT(s->st_size == sizeof(test_buf)); #ifndef _WIN32 r = fstat(file, &t); - ASSERT_OK(r); - - ASSERT_EQ(s->st_dev, (uint64_t) t.st_dev); - ASSERT_EQ(s->st_mode, (uint64_t) t.st_mode); - ASSERT_EQ(s->st_nlink, (uint64_t) t.st_nlink); - ASSERT_EQ(s->st_uid, (uint64_t) t.st_uid); - ASSERT_EQ(s->st_gid, (uint64_t) t.st_gid); - ASSERT_EQ(s->st_rdev, (uint64_t) t.st_rdev); - ASSERT_EQ(s->st_ino, (uint64_t) t.st_ino); - ASSERT_EQ(s->st_size, (uint64_t) t.st_size); - ASSERT_EQ(s->st_blksize, (uint64_t) t.st_blksize); - ASSERT_EQ(s->st_blocks, (uint64_t) t.st_blocks); + ASSERT(r == 0); + + ASSERT(s->st_dev == (uint64_t) t.st_dev); + ASSERT(s->st_mode == (uint64_t) t.st_mode); + ASSERT(s->st_nlink == (uint64_t) t.st_nlink); + ASSERT(s->st_uid == (uint64_t) t.st_uid); + ASSERT(s->st_gid == (uint64_t) t.st_gid); + ASSERT(s->st_rdev == (uint64_t) t.st_rdev); + ASSERT(s->st_ino == (uint64_t) t.st_ino); + ASSERT(s->st_size == (uint64_t) t.st_size); + ASSERT(s->st_blksize == (uint64_t) t.st_blksize); + ASSERT(s->st_blocks == (uint64_t) t.st_blocks); #if defined(__APPLE__) - ASSERT_EQ(s->st_atim.tv_sec, t.st_atimespec.tv_sec); - ASSERT_EQ(s->st_atim.tv_nsec, t.st_atimespec.tv_nsec); - ASSERT_EQ(s->st_mtim.tv_sec, t.st_mtimespec.tv_sec); - ASSERT_EQ(s->st_mtim.tv_nsec, t.st_mtimespec.tv_nsec); - ASSERT_EQ(s->st_ctim.tv_sec, t.st_ctimespec.tv_sec); - ASSERT_EQ(s->st_ctim.tv_nsec, t.st_ctimespec.tv_nsec); + ASSERT(s->st_atim.tv_sec == t.st_atimespec.tv_sec); + ASSERT(s->st_atim.tv_nsec == t.st_atimespec.tv_nsec); + ASSERT(s->st_mtim.tv_sec == t.st_mtimespec.tv_sec); + ASSERT(s->st_mtim.tv_nsec == t.st_mtimespec.tv_nsec); + ASSERT(s->st_ctim.tv_sec == t.st_ctimespec.tv_sec); + ASSERT(s->st_ctim.tv_nsec == t.st_ctimespec.tv_nsec); #elif defined(_AIX) || \ defined(__MVS__) - ASSERT_EQ(s->st_atim.tv_sec, t.st_atime); - ASSERT_OK(s->st_atim.tv_nsec); - ASSERT_EQ(s->st_mtim.tv_sec, t.st_mtime); - ASSERT_OK(s->st_mtim.tv_nsec); - ASSERT_EQ(s->st_ctim.tv_sec, t.st_ctime); - ASSERT_OK(s->st_ctim.tv_nsec); + ASSERT(s->st_atim.tv_sec == t.st_atime); + ASSERT(s->st_atim.tv_nsec == 0); + ASSERT(s->st_mtim.tv_sec == t.st_mtime); + ASSERT(s->st_mtim.tv_nsec == 0); + ASSERT(s->st_ctim.tv_sec == t.st_ctime); + ASSERT(s->st_ctim.tv_nsec == 0); #elif defined(__ANDROID__) - ASSERT_EQ(s->st_atim.tv_sec, t.st_atime); - ASSERT_EQ(s->st_atim.tv_nsec, t.st_atimensec); - ASSERT_EQ(s->st_mtim.tv_sec, t.st_mtime); - ASSERT_EQ(s->st_mtim.tv_nsec, t.st_mtimensec); - ASSERT_EQ(s->st_ctim.tv_sec, t.st_ctime); - ASSERT_EQ(s->st_ctim.tv_nsec, t.st_ctimensec); + ASSERT(s->st_atim.tv_sec == t.st_atime); + ASSERT(s->st_atim.tv_nsec == t.st_atimensec); + ASSERT(s->st_mtim.tv_sec == t.st_mtime); + ASSERT(s->st_mtim.tv_nsec == t.st_mtimensec); + ASSERT(s->st_ctim.tv_sec == t.st_ctime); + ASSERT(s->st_ctim.tv_nsec == t.st_ctimensec); #elif defined(__sun) || \ defined(__DragonFly__) || \ defined(__FreeBSD__) || \ @@ -1505,47 +1429,47 @@ TEST_IMPL(fs_fstat) { defined(_SVID_SOURCE) || \ defined(_XOPEN_SOURCE) || \ defined(_DEFAULT_SOURCE) - ASSERT_EQ(s->st_atim.tv_sec, t.st_atim.tv_sec); - ASSERT_EQ(s->st_atim.tv_nsec, t.st_atim.tv_nsec); - ASSERT_EQ(s->st_mtim.tv_sec, t.st_mtim.tv_sec); - ASSERT_EQ(s->st_mtim.tv_nsec, t.st_mtim.tv_nsec); - ASSERT_EQ(s->st_ctim.tv_sec, t.st_ctim.tv_sec); - ASSERT_EQ(s->st_ctim.tv_nsec, t.st_ctim.tv_nsec); + ASSERT(s->st_atim.tv_sec == t.st_atim.tv_sec); + ASSERT(s->st_atim.tv_nsec == t.st_atim.tv_nsec); + ASSERT(s->st_mtim.tv_sec == t.st_mtim.tv_sec); + ASSERT(s->st_mtim.tv_nsec == t.st_mtim.tv_nsec); + ASSERT(s->st_ctim.tv_sec == t.st_ctim.tv_sec); + ASSERT(s->st_ctim.tv_nsec == t.st_ctim.tv_nsec); # if defined(__FreeBSD__) || \ defined(__NetBSD__) - ASSERT_EQ(s->st_birthtim.tv_sec, t.st_birthtim.tv_sec); - ASSERT_EQ(s->st_birthtim.tv_nsec, t.st_birthtim.tv_nsec); + ASSERT(s->st_birthtim.tv_sec == t.st_birthtim.tv_sec); + ASSERT(s->st_birthtim.tv_nsec == t.st_birthtim.tv_nsec); # endif #else - ASSERT_EQ(s->st_atim.tv_sec, t.st_atime); - ASSERT_OK(s->st_atim.tv_nsec); - ASSERT_EQ(s->st_mtim.tv_sec, t.st_mtime); - ASSERT_OK(s->st_mtim.tv_nsec); - ASSERT_EQ(s->st_ctim.tv_sec, t.st_ctime); - ASSERT_OK(s->st_ctim.tv_nsec); + ASSERT(s->st_atim.tv_sec == t.st_atime); + ASSERT(s->st_atim.tv_nsec == 0); + ASSERT(s->st_mtim.tv_sec == t.st_mtime); + ASSERT(s->st_mtim.tv_nsec == 0); + ASSERT(s->st_ctim.tv_sec == t.st_ctime); + ASSERT(s->st_ctim.tv_nsec == 0); #endif #endif #if defined(__APPLE__) || defined(__FreeBSD__) || defined(__NetBSD__) - ASSERT_EQ(s->st_flags, t.st_flags); - ASSERT_EQ(s->st_gen, t.st_gen); + ASSERT(s->st_flags == t.st_flags); + ASSERT(s->st_gen == t.st_gen); #else - ASSERT_OK(s->st_flags); - ASSERT_OK(s->st_gen); + ASSERT(s->st_flags == 0); + ASSERT(s->st_gen == 0); #endif uv_fs_req_cleanup(&req); /* Now do the uv_fs_fstat call asynchronously */ r = uv_fs_fstat(loop, &req, file, fstat_cb); - ASSERT_OK(r); + ASSERT(r == 0); uv_run(loop, UV_RUN_DEFAULT); - ASSERT_EQ(1, fstat_cb_count); + ASSERT(fstat_cb_count == 1); r = uv_fs_close(NULL, &req, file, NULL); - ASSERT_OK(r); - ASSERT_OK(req.result); + ASSERT(r == 0); + ASSERT(req.result == 0); uv_fs_req_cleanup(&req); /* @@ -1557,46 +1481,7 @@ TEST_IMPL(fs_fstat) { /* Cleanup. */ unlink("test_file"); - MAKE_VALGRIND_HAPPY(loop); - return 0; -} - - -TEST_IMPL(fs_fstat_stdio) { - int fd; - int res; - uv_fs_t req; -#ifdef _WIN32 - uv_stat_t* st; - DWORD ft; -#endif - - for (fd = 0; fd <= 2; ++fd) { - res = uv_fs_fstat(NULL, &req, fd, NULL); - ASSERT_OK(res); - ASSERT_OK(req.result); - -#ifdef _WIN32 - st = req.ptr; - ft = uv_guess_handle(fd); - switch (ft) { - case UV_TTY: - case UV_NAMED_PIPE: - ASSERT_EQ(st->st_mode, (ft == UV_TTY ? S_IFCHR : S_IFIFO)); - ASSERT_EQ(1, st->st_nlink); - ASSERT_EQ(st->st_rdev, - (ft == UV_TTY ? FILE_DEVICE_CONSOLE : FILE_DEVICE_NAMED_PIPE) - << 16); - break; - default: - break; - } -#endif - - uv_fs_req_cleanup(&req); - } - - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -1614,52 +1499,52 @@ TEST_IMPL(fs_access) { /* File should not exist */ r = uv_fs_access(NULL, &req, "test_file", F_OK, NULL); - ASSERT_LT(r, 0); - ASSERT_LT(req.result, 0); + ASSERT(r < 0); + ASSERT(req.result < 0); uv_fs_req_cleanup(&req); /* File should not exist */ r = uv_fs_access(loop, &req, "test_file", F_OK, access_cb); - ASSERT_OK(r); + ASSERT(r == 0); uv_run(loop, UV_RUN_DEFAULT); - ASSERT_EQ(1, access_cb_count); + ASSERT(access_cb_count == 1); access_cb_count = 0; /* reset for the next test */ /* Create file */ - r = uv_fs_open(NULL, &req, "test_file", UV_FS_O_RDWR | UV_FS_O_CREAT, + r = uv_fs_open(NULL, &req, "test_file", O_RDWR | O_CREAT, S_IWUSR | S_IRUSR, NULL); - ASSERT_GE(r, 0); - ASSERT_GE(req.result, 0); + ASSERT(r >= 0); + ASSERT(req.result >= 0); file = req.result; uv_fs_req_cleanup(&req); /* File should exist */ r = uv_fs_access(NULL, &req, "test_file", F_OK, NULL); - ASSERT_OK(r); - ASSERT_OK(req.result); + ASSERT(r == 0); + ASSERT(req.result == 0); uv_fs_req_cleanup(&req); /* File should exist */ r = uv_fs_access(loop, &req, "test_file", F_OK, access_cb); - ASSERT_OK(r); + ASSERT(r == 0); uv_run(loop, UV_RUN_DEFAULT); - ASSERT_EQ(1, access_cb_count); + ASSERT(access_cb_count == 1); access_cb_count = 0; /* reset for the next test */ /* Close file */ r = uv_fs_close(NULL, &req, file, NULL); - ASSERT_OK(r); - ASSERT_OK(req.result); + ASSERT(r == 0); + ASSERT(req.result == 0); uv_fs_req_cleanup(&req); /* Directory access */ r = uv_fs_mkdir(NULL, &req, "test_dir", 0777, NULL); - ASSERT_OK(r); + ASSERT(r == 0); uv_fs_req_cleanup(&req); r = uv_fs_access(NULL, &req, "test_dir", W_OK, NULL); - ASSERT_OK(r); - ASSERT_OK(req.result); + ASSERT(r == 0); + ASSERT(req.result == 0); uv_fs_req_cleanup(&req); /* @@ -1672,7 +1557,7 @@ TEST_IMPL(fs_access) { unlink("test_file"); rmdir("test_dir"); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -1687,24 +1572,24 @@ TEST_IMPL(fs_chmod) { loop = uv_default_loop(); - r = uv_fs_open(NULL, &req, "test_file", UV_FS_O_RDWR | UV_FS_O_CREAT, + r = uv_fs_open(NULL, &req, "test_file", O_RDWR | O_CREAT, S_IWUSR | S_IRUSR, NULL); - ASSERT_GE(r, 0); - ASSERT_GE(req.result, 0); + ASSERT(r >= 0); + ASSERT(req.result >= 0); file = req.result; uv_fs_req_cleanup(&req); iov = uv_buf_init(test_buf, sizeof(test_buf)); r = uv_fs_write(NULL, &req, file, &iov, 1, -1, NULL); - ASSERT_EQ(r, sizeof(test_buf)); - ASSERT_EQ(req.result, sizeof(test_buf)); + ASSERT(r == sizeof(test_buf)); + ASSERT(req.result == sizeof(test_buf)); uv_fs_req_cleanup(&req); #ifndef _WIN32 /* Make the file write-only */ r = uv_fs_chmod(NULL, &req, "test_file", 0200, NULL); - ASSERT_OK(r); - ASSERT_OK(req.result); + ASSERT(r == 0); + ASSERT(req.result == 0); uv_fs_req_cleanup(&req); check_permission("test_file", 0200); @@ -1712,16 +1597,16 @@ TEST_IMPL(fs_chmod) { /* Make the file read-only */ r = uv_fs_chmod(NULL, &req, "test_file", 0400, NULL); - ASSERT_OK(r); - ASSERT_OK(req.result); + ASSERT(r == 0); + ASSERT(req.result == 0); uv_fs_req_cleanup(&req); check_permission("test_file", 0400); /* Make the file read+write with sync uv_fs_fchmod */ r = uv_fs_fchmod(NULL, &req, file, 0600, NULL); - ASSERT_OK(r); - ASSERT_OK(req.result); + ASSERT(r == 0); + ASSERT(req.result == 0); uv_fs_req_cleanup(&req); check_permission("test_file", 0600); @@ -1733,9 +1618,9 @@ TEST_IMPL(fs_chmod) { req.data = &mode; } r = uv_fs_chmod(loop, &req, "test_file", 0200, chmod_cb); - ASSERT_OK(r); + ASSERT(r == 0); uv_run(loop, UV_RUN_DEFAULT); - ASSERT_EQ(1, chmod_cb_count); + ASSERT(chmod_cb_count == 1); chmod_cb_count = 0; /* reset for the next test */ #endif @@ -1745,9 +1630,9 @@ TEST_IMPL(fs_chmod) { req.data = &mode; } r = uv_fs_chmod(loop, &req, "test_file", 0400, chmod_cb); - ASSERT_OK(r); + ASSERT(r == 0); uv_run(loop, UV_RUN_DEFAULT); - ASSERT_EQ(1, chmod_cb_count); + ASSERT(chmod_cb_count == 1); /* async fchmod */ { @@ -1755,9 +1640,9 @@ TEST_IMPL(fs_chmod) { req.data = &mode; } r = uv_fs_fchmod(loop, &req, file, 0600, fchmod_cb); - ASSERT_OK(r); + ASSERT(r == 0); uv_run(loop, UV_RUN_DEFAULT); - ASSERT_EQ(1, fchmod_cb_count); + ASSERT(fchmod_cb_count == 1); uv_fs_close(loop, &req, file, NULL); @@ -1770,7 +1655,7 @@ TEST_IMPL(fs_chmod) { /* Cleanup. */ unlink("test_file"); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -1786,34 +1671,36 @@ TEST_IMPL(fs_unlink_readonly) { loop = uv_default_loop(); r = uv_fs_open(NULL, - &req, "test_file", UV_FS_O_RDWR | UV_FS_O_CREAT, + &req, + "test_file", + O_RDWR | O_CREAT, S_IWUSR | S_IRUSR, NULL); - ASSERT_GE(r, 0); - ASSERT_GE(req.result, 0); + ASSERT(r >= 0); + ASSERT(req.result >= 0); file = req.result; uv_fs_req_cleanup(&req); iov = uv_buf_init(test_buf, sizeof(test_buf)); r = uv_fs_write(NULL, &req, file, &iov, 1, -1, NULL); - ASSERT_EQ(r, sizeof(test_buf)); - ASSERT_EQ(req.result, sizeof(test_buf)); + ASSERT(r == sizeof(test_buf)); + ASSERT(req.result == sizeof(test_buf)); uv_fs_req_cleanup(&req); uv_fs_close(loop, &req, file, NULL); /* Make the file read-only */ r = uv_fs_chmod(NULL, &req, "test_file", 0400, NULL); - ASSERT_OK(r); - ASSERT_OK(req.result); + ASSERT(r == 0); + ASSERT(req.result == 0); uv_fs_req_cleanup(&req); check_permission("test_file", 0400); /* Try to unlink the file */ r = uv_fs_unlink(NULL, &req, "test_file", NULL); - ASSERT_OK(r); - ASSERT_OK(req.result); + ASSERT(r == 0); + ASSERT(req.result == 0); uv_fs_req_cleanup(&req); /* @@ -1827,7 +1714,7 @@ TEST_IMPL(fs_unlink_readonly) { uv_fs_req_cleanup(&req); unlink("test_file"); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -1843,33 +1730,35 @@ TEST_IMPL(fs_unlink_archive_readonly) { loop = uv_default_loop(); r = uv_fs_open(NULL, - &req, "test_file", UV_FS_O_RDWR | UV_FS_O_CREAT, + &req, + "test_file", + O_RDWR | O_CREAT, S_IWUSR | S_IRUSR, NULL); - ASSERT_GE(r, 0); - ASSERT_GE(req.result, 0); + ASSERT(r >= 0); + ASSERT(req.result >= 0); file = req.result; uv_fs_req_cleanup(&req); iov = uv_buf_init(test_buf, sizeof(test_buf)); r = uv_fs_write(NULL, &req, file, &iov, 1, -1, NULL); - ASSERT_EQ(r, sizeof(test_buf)); - ASSERT_EQ(req.result, sizeof(test_buf)); + ASSERT(r == sizeof(test_buf)); + ASSERT(req.result == sizeof(test_buf)); uv_fs_req_cleanup(&req); uv_fs_close(loop, &req, file, NULL); /* Make the file read-only and clear archive flag */ r = SetFileAttributes("test_file", FILE_ATTRIBUTE_READONLY); - ASSERT(r); + ASSERT(r != 0); uv_fs_req_cleanup(&req); check_permission("test_file", 0400); /* Try to unlink the file */ r = uv_fs_unlink(NULL, &req, "test_file", NULL); - ASSERT_OK(r); - ASSERT_OK(req.result); + ASSERT(r == 0); + ASSERT(req.result == 0); uv_fs_req_cleanup(&req); /* @@ -1883,104 +1772,11 @@ TEST_IMPL(fs_unlink_archive_readonly) { uv_fs_req_cleanup(&req); unlink("test_file"); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } #endif -TEST_IMPL(fs_chown) { - int r; - uv_fs_t req; - uv_file file; - - /* Setup. */ - unlink("test_file"); - unlink("test_file_link"); - - loop = uv_default_loop(); - - r = uv_fs_open(NULL, &req, "test_file", UV_FS_O_RDWR | UV_FS_O_CREAT, - S_IWUSR | S_IRUSR, NULL); - ASSERT_GE(r, 0); - ASSERT_GE(req.result, 0); - file = req.result; - uv_fs_req_cleanup(&req); - - /* sync chown */ - r = uv_fs_chown(NULL, &req, "test_file", -1, -1, NULL); - ASSERT_OK(r); - ASSERT_OK(req.result); - uv_fs_req_cleanup(&req); - - /* sync fchown */ - r = uv_fs_fchown(NULL, &req, file, -1, -1, NULL); - ASSERT_OK(r); - ASSERT_OK(req.result); - uv_fs_req_cleanup(&req); - - /* async chown */ - r = uv_fs_chown(loop, &req, "test_file", -1, -1, chown_cb); - ASSERT_OK(r); - uv_run(loop, UV_RUN_DEFAULT); - ASSERT_EQ(1, chown_cb_count); - -#ifndef __MVS__ - /* chown to root (fail) */ - chown_cb_count = 0; - r = uv_fs_chown(loop, &req, "test_file", 0, 0, chown_root_cb); - ASSERT_OK(r); - uv_run(loop, UV_RUN_DEFAULT); - ASSERT_EQ(1, chown_cb_count); -#endif - - /* async fchown */ - r = uv_fs_fchown(loop, &req, file, -1, -1, fchown_cb); - ASSERT_OK(r); - uv_run(loop, UV_RUN_DEFAULT); - ASSERT_EQ(1, fchown_cb_count); - -#ifndef __HAIKU__ - /* Haiku doesn't support hardlink */ - /* sync link */ - r = uv_fs_link(NULL, &req, "test_file", "test_file_link", NULL); - ASSERT_OK(r); - ASSERT_OK(req.result); - uv_fs_req_cleanup(&req); - - /* sync lchown */ - r = uv_fs_lchown(NULL, &req, "test_file_link", -1, -1, NULL); - ASSERT_OK(r); - ASSERT_OK(req.result); - uv_fs_req_cleanup(&req); - - /* async lchown */ - r = uv_fs_lchown(loop, &req, "test_file_link", -1, -1, lchown_cb); - ASSERT_OK(r); - uv_run(loop, UV_RUN_DEFAULT); - ASSERT_EQ(1, lchown_cb_count); -#endif - - /* Close file */ - r = uv_fs_close(NULL, &req, file, NULL); - ASSERT_OK(r); - ASSERT_OK(req.result); - uv_fs_req_cleanup(&req); - - /* - * Run the loop just to check we don't have make any extraneous uv_ref() - * calls. This should drop out immediately. - */ - uv_run(loop, UV_RUN_DEFAULT); - - /* Cleanup. */ - unlink("test_file"); - unlink("test_file_link"); - - MAKE_VALGRIND_HAPPY(loop); - return 0; -} - - TEST_IMPL(fs_link) { int r; uv_fs_t req; @@ -1994,60 +1790,60 @@ TEST_IMPL(fs_link) { loop = uv_default_loop(); - r = uv_fs_open(NULL, &req, "test_file", UV_FS_O_RDWR | UV_FS_O_CREAT, + r = uv_fs_open(NULL, &req, "test_file", O_RDWR | O_CREAT, S_IWUSR | S_IRUSR, NULL); - ASSERT_GE(r, 0); - ASSERT_GE(req.result, 0); + ASSERT(r >= 0); + ASSERT(req.result >= 0); file = req.result; uv_fs_req_cleanup(&req); iov = uv_buf_init(test_buf, sizeof(test_buf)); r = uv_fs_write(NULL, &req, file, &iov, 1, -1, NULL); - ASSERT_EQ(r, sizeof(test_buf)); - ASSERT_EQ(req.result, sizeof(test_buf)); + ASSERT(r == sizeof(test_buf)); + ASSERT(req.result == sizeof(test_buf)); uv_fs_req_cleanup(&req); uv_fs_close(loop, &req, file, NULL); /* sync link */ r = uv_fs_link(NULL, &req, "test_file", "test_file_link", NULL); - ASSERT_OK(r); - ASSERT_OK(req.result); + ASSERT(r == 0); + ASSERT(req.result == 0); uv_fs_req_cleanup(&req); - r = uv_fs_open(NULL, &req, "test_file_link", UV_FS_O_RDWR, 0, NULL); - ASSERT_GE(r, 0); - ASSERT_GE(req.result, 0); + r = uv_fs_open(NULL, &req, "test_file_link", O_RDWR, 0, NULL); + ASSERT(r >= 0); + ASSERT(req.result >= 0); link = req.result; uv_fs_req_cleanup(&req); memset(buf, 0, sizeof(buf)); iov = uv_buf_init(buf, sizeof(buf)); r = uv_fs_read(NULL, &req, link, &iov, 1, 0, NULL); - ASSERT_GE(r, 0); - ASSERT_GE(req.result, 0); - ASSERT_OK(strcmp(buf, test_buf)); + ASSERT(r >= 0); + ASSERT(req.result >= 0); + ASSERT(strcmp(buf, test_buf) == 0); close(link); /* async link */ r = uv_fs_link(loop, &req, "test_file", "test_file_link2", link_cb); - ASSERT_OK(r); + ASSERT(r == 0); uv_run(loop, UV_RUN_DEFAULT); - ASSERT_EQ(1, link_cb_count); + ASSERT(link_cb_count == 1); - r = uv_fs_open(NULL, &req, "test_file_link2", UV_FS_O_RDWR, 0, NULL); - ASSERT_GE(r, 0); - ASSERT_GE(req.result, 0); + r = uv_fs_open(NULL, &req, "test_file_link2", O_RDWR, 0, NULL); + ASSERT(r >= 0); + ASSERT(req.result >= 0); link = req.result; uv_fs_req_cleanup(&req); memset(buf, 0, sizeof(buf)); iov = uv_buf_init(buf, sizeof(buf)); r = uv_fs_read(NULL, &req, link, &iov, 1, 0, NULL); - ASSERT_GE(r, 0); - ASSERT_GE(req.result, 0); - ASSERT_OK(strcmp(buf, test_buf)); + ASSERT(r >= 0); + ASSERT(req.result >= 0); + ASSERT(strcmp(buf, test_buf) == 0); uv_fs_close(loop, &req, link, NULL); @@ -2062,61 +1858,28 @@ TEST_IMPL(fs_link) { unlink("test_file_link"); unlink("test_file_link2"); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } TEST_IMPL(fs_readlink) { - /* Must return UV_ENOENT on an inexistent file */ - { - uv_fs_t req; - - loop = uv_default_loop(); - ASSERT_OK(uv_fs_readlink(loop, &req, "no_such_file", dummy_cb)); - ASSERT_OK(uv_run(loop, UV_RUN_DEFAULT)); - ASSERT_EQ(1, dummy_cb_count); - ASSERT_NULL(req.ptr); - ASSERT_EQ(req.result, UV_ENOENT); - uv_fs_req_cleanup(&req); - - ASSERT_EQ(UV_ENOENT, uv_fs_readlink(NULL, &req, "no_such_file", NULL)); - ASSERT_NULL(req.ptr); - ASSERT_EQ(req.result, UV_ENOENT); - uv_fs_req_cleanup(&req); - } - - /* Must return UV_EINVAL on a non-symlink file */ - { - int r; - uv_fs_t req; - uv_file file; - - /* Setup */ - - /* Create a non-symlink file */ - r = uv_fs_open(NULL, &req, "test_file", UV_FS_O_RDWR | UV_FS_O_CREAT, - S_IWUSR | S_IRUSR, NULL); - ASSERT_GE(r, 0); - ASSERT_GE(req.result, 0); - file = req.result; - uv_fs_req_cleanup(&req); - - r = uv_fs_close(NULL, &req, file, NULL); - ASSERT_OK(r); - ASSERT_OK(req.result); - uv_fs_req_cleanup(&req); + uv_fs_t req; - /* Test */ - r = uv_fs_readlink(NULL, &req, "test_file", NULL); - ASSERT_EQ(r, UV_EINVAL); - uv_fs_req_cleanup(&req); + loop = uv_default_loop(); + ASSERT(0 == uv_fs_readlink(loop, &req, "no_such_file", dummy_cb)); + ASSERT(0 == uv_run(loop, UV_RUN_DEFAULT)); + ASSERT(dummy_cb_count == 1); + ASSERT_NULL(req.ptr); + ASSERT(req.result == UV_ENOENT); + uv_fs_req_cleanup(&req); - /* Cleanup */ - unlink("test_file"); - } + ASSERT(UV_ENOENT == uv_fs_readlink(NULL, &req, "no_such_file", NULL)); + ASSERT_NULL(req.ptr); + ASSERT(req.result == UV_ENOENT); + uv_fs_req_cleanup(&req); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -2125,19 +1888,28 @@ TEST_IMPL(fs_realpath) { uv_fs_t req; loop = uv_default_loop(); - ASSERT_OK(uv_fs_realpath(loop, &req, "no_such_file", dummy_cb)); - ASSERT_OK(uv_run(loop, UV_RUN_DEFAULT)); - ASSERT_EQ(1, dummy_cb_count); + ASSERT(0 == uv_fs_realpath(loop, &req, "no_such_file", dummy_cb)); + ASSERT(0 == uv_run(loop, UV_RUN_DEFAULT)); + ASSERT(dummy_cb_count == 1); ASSERT_NULL(req.ptr); - ASSERT_EQ(req.result, UV_ENOENT); +#ifdef _WIN32 + /* + * Windows XP and Server 2003 don't support GetFinalPathNameByHandleW() + */ + if (req.result == UV_ENOSYS) { + uv_fs_req_cleanup(&req); + RETURN_SKIP("realpath is not supported on Windows XP"); + } +#endif + ASSERT(req.result == UV_ENOENT); uv_fs_req_cleanup(&req); - ASSERT_EQ(UV_ENOENT, uv_fs_realpath(NULL, &req, "no_such_file", NULL)); + ASSERT(UV_ENOENT == uv_fs_realpath(NULL, &req, "no_such_file", NULL)); ASSERT_NULL(req.ptr); - ASSERT_EQ(req.result, UV_ENOENT); + ASSERT(req.result == UV_ENOENT); uv_fs_req_cleanup(&req); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -2167,17 +1939,17 @@ TEST_IMPL(fs_symlink) { loop = uv_default_loop(); - r = uv_fs_open(NULL, &req, "test_file", UV_FS_O_RDWR | UV_FS_O_CREAT, + r = uv_fs_open(NULL, &req, "test_file", O_RDWR | O_CREAT, S_IWUSR | S_IRUSR, NULL); - ASSERT_GE(r, 0); - ASSERT_GE(req.result, 0); + ASSERT(r >= 0); + ASSERT(req.result >= 0); file = req.result; uv_fs_req_cleanup(&req); iov = uv_buf_init(test_buf, sizeof(test_buf)); r = uv_fs_write(NULL, &req, file, &iov, 1, -1, NULL); - ASSERT_EQ(r, sizeof(test_buf)); - ASSERT_EQ(req.result, sizeof(test_buf)); + ASSERT(r == sizeof(test_buf)); + ASSERT(req.result == sizeof(test_buf)); uv_fs_req_cleanup(&req); uv_fs_close(loop, &req, file, NULL); @@ -2201,22 +1973,22 @@ TEST_IMPL(fs_symlink) { } } #endif - ASSERT_OK(r); - ASSERT_OK(req.result); + ASSERT(r == 0); + ASSERT(req.result == 0); uv_fs_req_cleanup(&req); - r = uv_fs_open(NULL, &req, "test_file_symlink", UV_FS_O_RDWR, 0, NULL); - ASSERT_GE(r, 0); - ASSERT_GE(req.result, 0); + r = uv_fs_open(NULL, &req, "test_file_symlink", O_RDWR, 0, NULL); + ASSERT(r >= 0); + ASSERT(req.result >= 0); link = req.result; uv_fs_req_cleanup(&req); memset(buf, 0, sizeof(buf)); iov = uv_buf_init(buf, sizeof(buf)); r = uv_fs_read(NULL, &req, link, &iov, 1, 0, NULL); - ASSERT_GE(r, 0); - ASSERT_GE(req.result, 0); - ASSERT_OK(strcmp(buf, test_buf)); + ASSERT(r >= 0); + ASSERT(req.result >= 0); + ASSERT(strcmp(buf, test_buf) == 0); uv_fs_close(loop, &req, link, NULL); @@ -2226,7 +1998,7 @@ TEST_IMPL(fs_symlink) { "test_file_symlink_symlink", 0, NULL); - ASSERT_OK(r); + ASSERT(r == 0); uv_fs_req_cleanup(&req); #if defined(__MSYS__) @@ -2234,16 +2006,25 @@ TEST_IMPL(fs_symlink) { #endif r = uv_fs_readlink(NULL, &req, "test_file_symlink_symlink", NULL); - ASSERT_OK(r); - ASSERT_OK(strcmp(req.ptr, "test_file_symlink")); + ASSERT(r == 0); + ASSERT(strcmp(req.ptr, "test_file_symlink") == 0); uv_fs_req_cleanup(&req); r = uv_fs_realpath(NULL, &req, "test_file_symlink_symlink", NULL); - ASSERT_OK(r); #ifdef _WIN32 - ASSERT_OK(_stricmp(req.ptr, test_file_abs_buf)); + /* + * Windows XP and Server 2003 don't support GetFinalPathNameByHandleW() + */ + if (r == UV_ENOSYS) { + uv_fs_req_cleanup(&req); + RETURN_SKIP("realpath is not supported on Windows XP"); + } +#endif + ASSERT(r == 0); +#ifdef _WIN32 + ASSERT(stricmp(req.ptr, test_file_abs_buf) == 0); #else - ASSERT_OK(strcmp(req.ptr, test_file_abs_buf)); + ASSERT(strcmp(req.ptr, test_file_abs_buf) == 0); #endif uv_fs_req_cleanup(&req); @@ -2254,22 +2035,22 @@ TEST_IMPL(fs_symlink) { "test_file_symlink2", 0, symlink_cb); - ASSERT_OK(r); + ASSERT(r == 0); uv_run(loop, UV_RUN_DEFAULT); - ASSERT_EQ(1, symlink_cb_count); + ASSERT(symlink_cb_count == 1); - r = uv_fs_open(NULL, &req, "test_file_symlink2", UV_FS_O_RDWR, 0, NULL); - ASSERT_GE(r, 0); - ASSERT_GE(req.result, 0); + r = uv_fs_open(NULL, &req, "test_file_symlink2", O_RDWR, 0, NULL); + ASSERT(r >= 0); + ASSERT(req.result >= 0); link = req.result; uv_fs_req_cleanup(&req); memset(buf, 0, sizeof(buf)); iov = uv_buf_init(buf, sizeof(buf)); r = uv_fs_read(NULL, &req, link, &iov, 1, 0, NULL); - ASSERT_GE(r, 0); - ASSERT_GE(req.result, 0); - ASSERT_OK(strcmp(buf, test_buf)); + ASSERT(r >= 0); + ASSERT(req.result >= 0); + ASSERT(strcmp(buf, test_buf) == 0); uv_fs_close(loop, &req, link, NULL); @@ -2279,18 +2060,27 @@ TEST_IMPL(fs_symlink) { "test_file_symlink2_symlink", 0, NULL); - ASSERT_OK(r); + ASSERT(r == 0); uv_fs_req_cleanup(&req); r = uv_fs_readlink(loop, &req, "test_file_symlink2_symlink", readlink_cb); - ASSERT_OK(r); + ASSERT(r == 0); uv_run(loop, UV_RUN_DEFAULT); - ASSERT_EQ(1, readlink_cb_count); + ASSERT(readlink_cb_count == 1); r = uv_fs_realpath(loop, &req, "test_file", realpath_cb); - ASSERT_OK(r); +#ifdef _WIN32 + /* + * Windows XP and Server 2003 don't support GetFinalPathNameByHandleW() + */ + if (r == UV_ENOSYS) { + uv_fs_req_cleanup(&req); + RETURN_SKIP("realpath is not supported on Windows XP"); + } +#endif + ASSERT(r == 0); uv_run(loop, UV_RUN_DEFAULT); - ASSERT_EQ(1, realpath_cb_count); + ASSERT(realpath_cb_count == 1); /* * Run the loop just to check we don't have make any extraneous uv_ref() @@ -2305,7 +2095,7 @@ TEST_IMPL(fs_symlink) { unlink("test_file_symlink2"); unlink("test_file_symlink2_symlink"); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -2351,73 +2141,80 @@ int test_symlink_dir_impl(int type) { "creation of directory symlinks"); } fprintf(stderr, "r == %i\n", r); - ASSERT_OK(r); - ASSERT_OK(req.result); + ASSERT(r == 0); + ASSERT(req.result == 0); uv_fs_req_cleanup(&req); r = uv_fs_stat(NULL, &req, "test_dir_symlink", NULL); - ASSERT_OK(r); + ASSERT(r == 0); ASSERT(((uv_stat_t*)req.ptr)->st_mode & S_IFDIR); uv_fs_req_cleanup(&req); r = uv_fs_lstat(NULL, &req, "test_dir_symlink", NULL); - ASSERT_OK(r); + ASSERT(r == 0); #if defined(__MSYS__) RETURN_SKIP("symlink reading is not supported on MSYS2"); #endif ASSERT(((uv_stat_t*)req.ptr)->st_mode & S_IFLNK); #ifdef _WIN32 - ASSERT_EQ(((uv_stat_t*)req.ptr)->st_size, strlen(test_dir + 4)); + ASSERT(((uv_stat_t*)req.ptr)->st_size == strlen(test_dir + 4)); #else # ifdef __PASE__ /* On IBMi PASE, st_size returns the length of the symlink itself. */ - ASSERT_EQ(((uv_stat_t*)req.ptr)->st_size, strlen("test_dir_symlink")); + ASSERT(((uv_stat_t*)req.ptr)->st_size == strlen("test_dir_symlink")); # else - ASSERT_EQ(((uv_stat_t*)req.ptr)->st_size, strlen(test_dir)); + ASSERT(((uv_stat_t*)req.ptr)->st_size == strlen(test_dir)); # endif #endif uv_fs_req_cleanup(&req); r = uv_fs_readlink(NULL, &req, "test_dir_symlink", NULL); - ASSERT_OK(r); + ASSERT(r == 0); #ifdef _WIN32 - ASSERT_OK(strcmp(req.ptr, test_dir + 4)); + ASSERT(strcmp(req.ptr, test_dir + 4) == 0); #else - ASSERT_OK(strcmp(req.ptr, test_dir)); + ASSERT(strcmp(req.ptr, test_dir) == 0); #endif uv_fs_req_cleanup(&req); r = uv_fs_realpath(NULL, &req, "test_dir_symlink", NULL); - ASSERT_OK(r); #ifdef _WIN32 - ASSERT_EQ(strlen(req.ptr), test_dir_abs_size - 5); - ASSERT_OK(_strnicmp(req.ptr, test_dir + 4, test_dir_abs_size - 5)); + /* + * Windows XP and Server 2003 don't support GetFinalPathNameByHandleW() + */ + if (r == UV_ENOSYS) { + uv_fs_req_cleanup(&req); + RETURN_SKIP("realpath is not supported on Windows XP"); + } +#endif + ASSERT(r == 0); +#ifdef _WIN32 + ASSERT(strlen(req.ptr) == test_dir_abs_size - 5); + ASSERT(strnicmp(req.ptr, test_dir + 4, test_dir_abs_size - 5) == 0); #else - ASSERT_OK(strcmp(req.ptr, test_dir_abs_buf)); + ASSERT(strcmp(req.ptr, test_dir_abs_buf) == 0); #endif uv_fs_req_cleanup(&req); - r = uv_fs_open(NULL, &open_req1, "test_dir/file1", - UV_FS_O_WRONLY | UV_FS_O_CREAT, + r = uv_fs_open(NULL, &open_req1, "test_dir/file1", O_WRONLY | O_CREAT, S_IWUSR | S_IRUSR, NULL); - ASSERT_GE(r, 0); + ASSERT(r >= 0); uv_fs_req_cleanup(&open_req1); r = uv_fs_close(NULL, &close_req, open_req1.result, NULL); - ASSERT_OK(r); + ASSERT(r == 0); uv_fs_req_cleanup(&close_req); - r = uv_fs_open(NULL, &open_req1, "test_dir/file2", - UV_FS_O_WRONLY | UV_FS_O_CREAT, + r = uv_fs_open(NULL, &open_req1, "test_dir/file2", O_WRONLY | O_CREAT, S_IWUSR | S_IRUSR, NULL); - ASSERT_GE(r, 0); + ASSERT(r >= 0); uv_fs_req_cleanup(&open_req1); r = uv_fs_close(NULL, &close_req, open_req1.result, NULL); - ASSERT_OK(r); + ASSERT(r == 0); uv_fs_req_cleanup(&close_req); r = uv_fs_scandir(NULL, &scandir_req, "test_dir_symlink", 0, NULL); - ASSERT_EQ(2, r); - ASSERT_EQ(2, scandir_req.result); + ASSERT(r == 2); + ASSERT(scandir_req.result == 2); ASSERT(scandir_req.ptr); while (UV_EOF != uv_fs_scandir_next(&scandir_req, &dent)) { ASSERT(strcmp(dent.name, "file1") == 0 || strcmp(dent.name, "file2") == 0); @@ -2428,16 +2225,16 @@ int test_symlink_dir_impl(int type) { /* unlink will remove the directory symlink */ r = uv_fs_unlink(NULL, &req, "test_dir_symlink", NULL); - ASSERT_OK(r); + ASSERT(r == 0); uv_fs_req_cleanup(&req); r = uv_fs_scandir(NULL, &scandir_req, "test_dir_symlink", 0, NULL); - ASSERT_EQ(r, UV_ENOENT); + ASSERT(r == UV_ENOENT); uv_fs_req_cleanup(&scandir_req); r = uv_fs_scandir(NULL, &scandir_req, "test_dir", 0, NULL); - ASSERT_EQ(2, r); - ASSERT_EQ(2, scandir_req.result); + ASSERT(r == 2); + ASSERT(scandir_req.result == 2); ASSERT(scandir_req.ptr); while (UV_EOF != uv_fs_scandir_next(&scandir_req, &dent)) { ASSERT(strcmp(dent.name, "file1") == 0 || strcmp(dent.name, "file2") == 0); @@ -2452,7 +2249,7 @@ int test_symlink_dir_impl(int type) { rmdir("test_dir"); rmdir("test_dir_symlink"); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -2490,7 +2287,7 @@ TEST_IMPL(fs_non_symlink_reparse_point) { FILE_FLAG_OPEN_REPARSE_POINT | FILE_FLAG_BACKUP_SEMANTICS, NULL); - ASSERT_PTR_NE(file_handle, INVALID_HANDLE_VALUE); + ASSERT(file_handle != INVALID_HANDLE_VALUE); memset(&reparse_buffer, 0, REPARSE_GUID_DATA_BUFFER_HEADER_SIZE); reparse_buffer.ReparseTag = REPARSE_TAG; @@ -2505,7 +2302,7 @@ TEST_IMPL(fs_non_symlink_reparse_point) { 0, &bytes_returned, NULL); - ASSERT(r); + ASSERT(r != 0); CloseHandle(file_handle); @@ -2519,11 +2316,11 @@ TEST_IMPL(fs_non_symlink_reparse_point) { shared via SMB as "Macintosh HD". r = uv_fs_stat(NULL, &req, "\\\\\\Macintosh HD\\.DS_Store", NULL); - ASSERT_OK(r); + ASSERT(r == 0); uv_fs_req_cleanup(&req); r = uv_fs_lstat(NULL, &req, "\\\\\\Macintosh HD\\.DS_Store", NULL); - ASSERT_OK(r); + ASSERT(r == 0); uv_fs_req_cleanup(&req); */ @@ -2534,25 +2331,25 @@ TEST_IMPL(fs_non_symlink_reparse_point) { the scope of this test. r = uv_fs_stat(NULL, &req, "test_dir/test_file", NULL); - ASSERT_OK(r); + ASSERT(r == 0); uv_fs_req_cleanup(&req); r = uv_fs_lstat(NULL, &req, "test_dir/test_file", NULL); - ASSERT_OK(r); + ASSERT(r == 0); uv_fs_req_cleanup(&req); */ r = uv_fs_scandir(NULL, &scandir_req, "test_dir", 0, NULL); - ASSERT_EQ(1, r); - ASSERT_EQ(1, scandir_req.result); + ASSERT(r == 1); + ASSERT(scandir_req.result == 1); ASSERT(scandir_req.ptr); while (UV_EOF != uv_fs_scandir_next(&scandir_req, &dent)) { - ASSERT_OK(strcmp(dent.name, "test_file")); + ASSERT(strcmp(dent.name, "test_file") == 0); /* uv_fs_scandir incorrectly identifies non-symlink reparse points as links because it doesn't open the file and verify the reparse point tag. The PowerShell Get-ChildItem command shares this behavior, so it's reasonable to leave it as is. */ - ASSERT_EQ(dent.type, UV_DIRENT_LINK); + ASSERT(dent.type == UV_DIRENT_LINK); } uv_fs_req_cleanup(&scandir_req); ASSERT(!scandir_req.ptr); @@ -2561,7 +2358,7 @@ TEST_IMPL(fs_non_symlink_reparse_point) { unlink("test_dir/test_file"); rmdir("test_dir"); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -2581,10 +2378,10 @@ TEST_IMPL(fs_lstat_windows_store_apps) { len = sizeof(localappdata); r = uv_os_getenv("LOCALAPPDATA", localappdata, &len); if (r == UV_ENOENT) { - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return TEST_SKIP; } - ASSERT_OK(r); + ASSERT_EQ(r, 0); r = snprintf(windowsapps_path, sizeof(localappdata), "%s\\Microsoft\\WindowsApps", @@ -2592,11 +2389,11 @@ TEST_IMPL(fs_lstat_windows_store_apps) { ASSERT_GT(r, 0); if (uv_fs_opendir(loop, &req, windowsapps_path, NULL) != 0) { /* If we cannot read the directory, skip the test. */ - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return TEST_SKIP; } if (uv_fs_scandir(loop, &req, windowsapps_path, 0, NULL) <= 0) { - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return TEST_SKIP; } while (uv_fs_scandir_next(&req, &dirent) != UV_EOF) { @@ -2610,9 +2407,9 @@ TEST_IMPL(fs_lstat_windows_store_apps) { dirent.name) < 0) { continue; } - ASSERT_OK(uv_fs_lstat(loop, &stat_req, file_path, NULL)); + ASSERT_EQ(uv_fs_lstat(loop, &stat_req, file_path, NULL), 0); } - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } #endif @@ -2629,19 +2426,17 @@ TEST_IMPL(fs_utime) { /* Setup. */ loop = uv_default_loop(); unlink(path); - r = uv_fs_open(NULL, &req, path, UV_FS_O_RDWR | UV_FS_O_CREAT, - S_IWUSR | S_IRUSR, - NULL); - ASSERT_GE(r, 0); - ASSERT_GE(req.result, 0); + r = uv_fs_open(NULL, &req, path, O_RDWR | O_CREAT, S_IWUSR | S_IRUSR, NULL); + ASSERT(r >= 0); + ASSERT(req.result >= 0); uv_fs_req_cleanup(&req); uv_fs_close(loop, &req, r, NULL); atime = mtime = 400497753.25; /* 1982-09-10 11:22:33.25 */ r = uv_fs_utime(NULL, &req, path, atime, mtime, NULL); - ASSERT_OK(r); - ASSERT_OK(req.result); + ASSERT(r == 0); + ASSERT(req.result == 0); uv_fs_req_cleanup(&req); check_utime(path, atime, mtime, /* test_lutime */ 0); @@ -2654,14 +2449,14 @@ TEST_IMPL(fs_utime) { /* async utime */ utime_req.data = &checkme; r = uv_fs_utime(loop, &utime_req, path, atime, mtime, utime_cb); - ASSERT_OK(r); + ASSERT(r == 0); uv_run(loop, UV_RUN_DEFAULT); - ASSERT_EQ(1, utime_cb_count); + ASSERT(utime_cb_count == 1); /* Cleanup. */ unlink(path); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -2675,13 +2470,11 @@ TEST_IMPL(fs_utime_round) { loop = uv_default_loop(); unlink(path); - r = uv_fs_open(NULL, &req, path, UV_FS_O_RDWR | UV_FS_O_CREAT, - S_IWUSR | S_IRUSR, - NULL); + r = uv_fs_open(NULL, &req, path, O_RDWR | O_CREAT, S_IWUSR | S_IRUSR, NULL); ASSERT_GE(r, 0); ASSERT_GE(req.result, 0); uv_fs_req_cleanup(&req); - ASSERT_OK(uv_fs_close(loop, &req, r, NULL)); + ASSERT_EQ(0, uv_fs_close(loop, &req, r, NULL)); atime = mtime = -14245440.25; /* 1969-07-20T02:56:00.25Z */ @@ -2696,13 +2489,13 @@ TEST_IMPL(fs_utime_round) { RETURN_SKIP("utime on some OS (z/OS, IBM i PASE, AIX) or filesystems may reject pre-epoch timestamps"); } #endif - ASSERT_OK(r); - ASSERT_OK(req.result); + ASSERT_EQ(0, r); + ASSERT_EQ(0, req.result); uv_fs_req_cleanup(&req); check_utime(path, atime, mtime, /* test_lutime */ 0); unlink(path); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -2712,28 +2505,28 @@ TEST_IMPL(fs_stat_root) { int r; r = uv_fs_stat(NULL, &stat_req, "\\", NULL); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_fs_stat(NULL, &stat_req, "..\\..\\..\\..\\..\\..\\..", NULL); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_fs_stat(NULL, &stat_req, "..", NULL); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_fs_stat(NULL, &stat_req, "..\\", NULL); - ASSERT_OK(r); + ASSERT(r == 0); /* stats the current directory on c: */ r = uv_fs_stat(NULL, &stat_req, "c:", NULL); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_fs_stat(NULL, &stat_req, "c:\\", NULL); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_fs_stat(NULL, &stat_req, "\\\\?\\C:\\", NULL); - ASSERT_OK(r); + ASSERT(r == 0); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } #endif @@ -2754,29 +2547,27 @@ TEST_IMPL(fs_futime) { /* Setup. */ loop = uv_default_loop(); unlink(path); - r = uv_fs_open(NULL, &req, path, UV_FS_O_RDWR | UV_FS_O_CREAT, - S_IWUSR | S_IRUSR, - NULL); - ASSERT_GE(r, 0); - ASSERT_GE(req.result, 0); + r = uv_fs_open(NULL, &req, path, O_RDWR | O_CREAT, S_IWUSR | S_IRUSR, NULL); + ASSERT(r >= 0); + ASSERT(req.result >= 0); uv_fs_req_cleanup(&req); uv_fs_close(loop, &req, r, NULL); atime = mtime = 400497753.25; /* 1982-09-10 11:22:33.25 */ - r = uv_fs_open(NULL, &req, path, UV_FS_O_RDWR, 0, NULL); - ASSERT_GE(r, 0); - ASSERT_GE(req.result, 0); + r = uv_fs_open(NULL, &req, path, O_RDWR, 0, NULL); + ASSERT(r >= 0); + ASSERT(req.result >= 0); file = req.result; /* FIXME probably not how it's supposed to be used */ uv_fs_req_cleanup(&req); r = uv_fs_futime(NULL, &req, file, atime, mtime, NULL); #if defined(__CYGWIN__) || defined(__MSYS__) - ASSERT_EQ(r, UV_ENOSYS); + ASSERT(r == UV_ENOSYS); RETURN_SKIP("futime not supported on Cygwin"); #else - ASSERT_OK(r); - ASSERT_OK(req.result); + ASSERT(r == 0); + ASSERT(req.result == 0); #endif uv_fs_req_cleanup(&req); @@ -2791,14 +2582,14 @@ TEST_IMPL(fs_futime) { /* async futime */ futime_req.data = &checkme; r = uv_fs_futime(loop, &futime_req, file, atime, mtime, futime_cb); - ASSERT_OK(r); + ASSERT(r == 0); uv_run(loop, UV_RUN_DEFAULT); - ASSERT_EQ(1, futime_cb_count); + ASSERT(futime_cb_count == 1); /* Cleanup. */ unlink(path); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -2816,11 +2607,9 @@ TEST_IMPL(fs_lutime) { /* Setup */ loop = uv_default_loop(); unlink(path); - r = uv_fs_open(NULL, &req, path, UV_FS_O_RDWR | UV_FS_O_CREAT, - S_IWUSR | S_IRUSR, - NULL); - ASSERT_GE(r, 0); - ASSERT_GE(req.result, 0); + r = uv_fs_open(NULL, &req, path, O_RDWR | O_CREAT, S_IWUSR | S_IRUSR, NULL); + ASSERT(r >= 0); + ASSERT(req.result >= 0); uv_fs_req_cleanup(&req); uv_fs_close(loop, &req, r, NULL); @@ -2836,8 +2625,8 @@ TEST_IMPL(fs_lutime) { "Symlink creation requires elevated console (with admin rights)"); } #endif - ASSERT_OK(s); - ASSERT_OK(req.result); + ASSERT(s == 0); + ASSERT(req.result == 0); uv_fs_req_cleanup(&req); /* Test the synchronous version. */ @@ -2851,12 +2640,12 @@ TEST_IMPL(fs_lutime) { r = uv_fs_lutime(NULL, &req, symlink_path, atime, mtime, NULL); #if (defined(_AIX) && !defined(_AIX71)) || \ defined(__MVS__) - ASSERT_EQ(r, UV_ENOSYS); + ASSERT(r == UV_ENOSYS); RETURN_SKIP("lutime is not implemented for z/OS and AIX versions below 7.1"); #endif - ASSERT_OK(r); + ASSERT(r == 0); lutime_cb(&req); - ASSERT_EQ(1, lutime_cb_count); + ASSERT(lutime_cb_count == 1); /* Test the asynchronous version. */ atime = mtime = 1291404900; /* 2010-12-03 20:35:00 */ @@ -2866,15 +2655,15 @@ TEST_IMPL(fs_lutime) { checkme.path = symlink_path; r = uv_fs_lutime(loop, &req, symlink_path, atime, mtime, lutime_cb); - ASSERT_OK(r); + ASSERT(r == 0); uv_run(loop, UV_RUN_DEFAULT); - ASSERT_EQ(2, lutime_cb_count); + ASSERT(lutime_cb_count == 2); /* Cleanup. */ unlink(path); unlink(symlink_path); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -2886,11 +2675,11 @@ TEST_IMPL(fs_stat_missing_path) { loop = uv_default_loop(); r = uv_fs_stat(NULL, &req, "non_existent_file", NULL); - ASSERT_EQ(r, UV_ENOENT); - ASSERT_EQ(req.result, UV_ENOENT); + ASSERT(r == UV_ENOENT); + ASSERT(req.result == UV_ENOENT); uv_fs_req_cleanup(&req); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -2911,23 +2700,23 @@ TEST_IMPL(fs_scandir_empty_dir) { memset(&req, 0xdb, sizeof(req)); r = uv_fs_scandir(NULL, &req, path, 0, NULL); - ASSERT_OK(r); - ASSERT_OK(req.result); + ASSERT(r == 0); + ASSERT(req.result == 0); ASSERT_NULL(req.ptr); - ASSERT_EQ(UV_EOF, uv_fs_scandir_next(&req, &dent)); + ASSERT(UV_EOF == uv_fs_scandir_next(&req, &dent)); uv_fs_req_cleanup(&req); r = uv_fs_scandir(loop, &scandir_req, path, 0, empty_scandir_cb); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_OK(scandir_cb_count); + ASSERT(scandir_cb_count == 0); uv_run(loop, UV_RUN_DEFAULT); - ASSERT_EQ(1, scandir_cb_count); + ASSERT(scandir_cb_count == 1); uv_fs_rmdir(NULL, &req, path, NULL); uv_fs_req_cleanup(&req); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -2948,20 +2737,20 @@ TEST_IMPL(fs_scandir_non_existent_dir) { memset(&req, 0xdb, sizeof(req)); r = uv_fs_scandir(NULL, &req, path, 0, NULL); - ASSERT_EQ(r, UV_ENOENT); - ASSERT_EQ(req.result, UV_ENOENT); + ASSERT(r == UV_ENOENT); + ASSERT(req.result == UV_ENOENT); ASSERT_NULL(req.ptr); - ASSERT_EQ(UV_ENOENT, uv_fs_scandir_next(&req, &dent)); + ASSERT(UV_ENOENT == uv_fs_scandir_next(&req, &dent)); uv_fs_req_cleanup(&req); r = uv_fs_scandir(loop, &scandir_req, path, 0, non_existent_scandir_cb); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_OK(scandir_cb_count); + ASSERT(scandir_cb_count == 0); uv_run(loop, UV_RUN_DEFAULT); - ASSERT_EQ(1, scandir_cb_count); + ASSERT(scandir_cb_count == 1); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -2973,35 +2762,17 @@ TEST_IMPL(fs_scandir_file) { loop = uv_default_loop(); r = uv_fs_scandir(NULL, &scandir_req, path, 0, NULL); - ASSERT_EQ(r, UV_ENOTDIR); + ASSERT(r == UV_ENOTDIR); uv_fs_req_cleanup(&scandir_req); r = uv_fs_scandir(loop, &scandir_req, path, 0, file_scandir_cb); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_OK(scandir_cb_count); + ASSERT(scandir_cb_count == 0); uv_run(loop, UV_RUN_DEFAULT); - ASSERT_EQ(1, scandir_cb_count); - - MAKE_VALGRIND_HAPPY(loop); - return 0; -} - - -/* Run in Valgrind. Should not leak when the iterator isn't exhausted. */ -TEST_IMPL(fs_scandir_early_exit) { - uv_dirent_t d; - uv_fs_t req; - - ASSERT_LT(0, uv_fs_scandir(NULL, &req, "test/fixtures/one_file", 0, NULL)); - ASSERT_NE(UV_EOF, uv_fs_scandir_next(&req, &d)); - uv_fs_req_cleanup(&req); - - ASSERT_LT(0, uv_fs_scandir(NULL, &req, "test/fixtures", 0, NULL)); - ASSERT_NE(UV_EOF, uv_fs_scandir_next(&req, &d)); - uv_fs_req_cleanup(&req); + ASSERT(scandir_cb_count == 1); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -3014,24 +2785,24 @@ TEST_IMPL(fs_open_dir) { path = "."; loop = uv_default_loop(); - r = uv_fs_open(NULL, &req, path, UV_FS_O_RDONLY, 0, NULL); - ASSERT_GE(r, 0); - ASSERT_GE(req.result, 0); + r = uv_fs_open(NULL, &req, path, O_RDONLY, 0, NULL); + ASSERT(r >= 0); + ASSERT(req.result >= 0); ASSERT_NULL(req.ptr); file = r; uv_fs_req_cleanup(&req); r = uv_fs_close(NULL, &req, file, NULL); - ASSERT_OK(r); + ASSERT(r == 0); - r = uv_fs_open(loop, &req, path, UV_FS_O_RDONLY, 0, open_cb_simple); - ASSERT_OK(r); + r = uv_fs_open(loop, &req, path, O_RDONLY, 0, open_cb_simple); + ASSERT(r == 0); - ASSERT_OK(open_cb_count); + ASSERT(open_cb_count == 0); uv_run(loop, UV_RUN_DEFAULT); - ASSERT_EQ(1, open_cb_count); + ASSERT(open_cb_count == 1); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -3045,59 +2816,58 @@ static void fs_file_open_append(int add_flags) { loop = uv_default_loop(); r = uv_fs_open(NULL, &open_req1, "test_file", - UV_FS_O_WRONLY | UV_FS_O_CREAT | add_flags, S_IWUSR | S_IRUSR, - NULL); - ASSERT_GE(r, 0); - ASSERT_GE(open_req1.result, 0); + O_WRONLY | O_CREAT | add_flags, S_IWUSR | S_IRUSR, NULL); + ASSERT(r >= 0); + ASSERT(open_req1.result >= 0); uv_fs_req_cleanup(&open_req1); iov = uv_buf_init(test_buf, sizeof(test_buf)); r = uv_fs_write(NULL, &write_req, open_req1.result, &iov, 1, -1, NULL); - ASSERT_GE(r, 0); - ASSERT_GE(write_req.result, 0); + ASSERT(r >= 0); + ASSERT(write_req.result >= 0); uv_fs_req_cleanup(&write_req); r = uv_fs_close(NULL, &close_req, open_req1.result, NULL); - ASSERT_OK(r); - ASSERT_OK(close_req.result); + ASSERT(r == 0); + ASSERT(close_req.result == 0); uv_fs_req_cleanup(&close_req); r = uv_fs_open(NULL, &open_req1, "test_file", - UV_FS_O_RDWR | UV_FS_O_APPEND | add_flags, 0, NULL); - ASSERT_GE(r, 0); - ASSERT_GE(open_req1.result, 0); + O_RDWR | O_APPEND | add_flags, 0, NULL); + ASSERT(r >= 0); + ASSERT(open_req1.result >= 0); uv_fs_req_cleanup(&open_req1); iov = uv_buf_init(test_buf, sizeof(test_buf)); r = uv_fs_write(NULL, &write_req, open_req1.result, &iov, 1, -1, NULL); - ASSERT_GE(r, 0); - ASSERT_GE(write_req.result, 0); + ASSERT(r >= 0); + ASSERT(write_req.result >= 0); uv_fs_req_cleanup(&write_req); r = uv_fs_close(NULL, &close_req, open_req1.result, NULL); - ASSERT_OK(r); - ASSERT_OK(close_req.result); + ASSERT(r == 0); + ASSERT(close_req.result == 0); uv_fs_req_cleanup(&close_req); - r = uv_fs_open(NULL, &open_req1, "test_file", UV_FS_O_RDONLY | add_flags, + r = uv_fs_open(NULL, &open_req1, "test_file", O_RDONLY | add_flags, S_IRUSR, NULL); - ASSERT_GE(r, 0); - ASSERT_GE(open_req1.result, 0); + ASSERT(r >= 0); + ASSERT(open_req1.result >= 0); uv_fs_req_cleanup(&open_req1); iov = uv_buf_init(buf, sizeof(buf)); r = uv_fs_read(NULL, &read_req, open_req1.result, &iov, 1, -1, NULL); printf("read = %d\n", r); - ASSERT_EQ(26, r); - ASSERT_EQ(26, read_req.result); - ASSERT_OK(memcmp(buf, - "test-buffer\n\0test-buffer\n\0", - sizeof("test-buffer\n\0test-buffer\n\0") - 1)); + ASSERT(r == 26); + ASSERT(read_req.result == 26); + ASSERT(memcmp(buf, + "test-buffer\n\0test-buffer\n\0", + sizeof("test-buffer\n\0test-buffer\n\0") - 1) == 0); uv_fs_req_cleanup(&read_req); r = uv_fs_close(NULL, &close_req, open_req1.result, NULL); - ASSERT_OK(r); - ASSERT_OK(close_req.result); + ASSERT(r == 0); + ASSERT(close_req.result == 0); uv_fs_req_cleanup(&close_req); /* Cleanup */ @@ -3107,7 +2877,7 @@ TEST_IMPL(fs_file_open_append) { fs_file_open_append(0); fs_file_open_append(UV_FS_O_FILEMAP); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -3121,62 +2891,62 @@ TEST_IMPL(fs_rename_to_existing_file) { loop = uv_default_loop(); - r = uv_fs_open(NULL, &open_req1, "test_file", UV_FS_O_WRONLY | UV_FS_O_CREAT, + r = uv_fs_open(NULL, &open_req1, "test_file", O_WRONLY | O_CREAT, S_IWUSR | S_IRUSR, NULL); - ASSERT_GE(r, 0); - ASSERT_GE(open_req1.result, 0); + ASSERT(r >= 0); + ASSERT(open_req1.result >= 0); uv_fs_req_cleanup(&open_req1); iov = uv_buf_init(test_buf, sizeof(test_buf)); r = uv_fs_write(NULL, &write_req, open_req1.result, &iov, 1, -1, NULL); - ASSERT_GE(r, 0); - ASSERT_GE(write_req.result, 0); + ASSERT(r >= 0); + ASSERT(write_req.result >= 0); uv_fs_req_cleanup(&write_req); r = uv_fs_close(NULL, &close_req, open_req1.result, NULL); - ASSERT_OK(r); - ASSERT_OK(close_req.result); + ASSERT(r == 0); + ASSERT(close_req.result == 0); uv_fs_req_cleanup(&close_req); - r = uv_fs_open(NULL, &open_req1, "test_file2", UV_FS_O_WRONLY | UV_FS_O_CREAT, + r = uv_fs_open(NULL, &open_req1, "test_file2", O_WRONLY | O_CREAT, S_IWUSR | S_IRUSR, NULL); - ASSERT_GE(r, 0); - ASSERT_GE(open_req1.result, 0); + ASSERT(r >= 0); + ASSERT(open_req1.result >= 0); uv_fs_req_cleanup(&open_req1); r = uv_fs_close(NULL, &close_req, open_req1.result, NULL); - ASSERT_OK(r); - ASSERT_OK(close_req.result); + ASSERT(r == 0); + ASSERT(close_req.result == 0); uv_fs_req_cleanup(&close_req); r = uv_fs_rename(NULL, &rename_req, "test_file", "test_file2", NULL); - ASSERT_OK(r); - ASSERT_OK(rename_req.result); + ASSERT(r == 0); + ASSERT(rename_req.result == 0); uv_fs_req_cleanup(&rename_req); - r = uv_fs_open(NULL, &open_req1, "test_file2", UV_FS_O_RDONLY, 0, NULL); - ASSERT_GE(r, 0); - ASSERT_GE(open_req1.result, 0); + r = uv_fs_open(NULL, &open_req1, "test_file2", O_RDONLY, 0, NULL); + ASSERT(r >= 0); + ASSERT(open_req1.result >= 0); uv_fs_req_cleanup(&open_req1); memset(buf, 0, sizeof(buf)); iov = uv_buf_init(buf, sizeof(buf)); r = uv_fs_read(NULL, &read_req, open_req1.result, &iov, 1, -1, NULL); - ASSERT_GE(r, 0); - ASSERT_GE(read_req.result, 0); - ASSERT_OK(strcmp(buf, test_buf)); + ASSERT(r >= 0); + ASSERT(read_req.result >= 0); + ASSERT(strcmp(buf, test_buf) == 0); uv_fs_req_cleanup(&read_req); r = uv_fs_close(NULL, &close_req, open_req1.result, NULL); - ASSERT_OK(r); - ASSERT_OK(close_req.result); + ASSERT(r == 0); + ASSERT(close_req.result == 0); uv_fs_req_cleanup(&close_req); /* Cleanup */ unlink("test_file"); unlink("test_file2"); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -3185,56 +2955,56 @@ static void fs_read_bufs(int add_flags) { char scratch[768]; uv_buf_t bufs[4]; - ASSERT_LE(0, uv_fs_open(NULL, &open_req1, - "test/fixtures/lorem_ipsum.txt", - UV_FS_O_RDONLY | add_flags, 0, NULL)); - ASSERT_GE(open_req1.result, 0); + ASSERT(0 <= uv_fs_open(NULL, &open_req1, + "test/fixtures/lorem_ipsum.txt", + O_RDONLY | add_flags, 0, NULL)); + ASSERT(open_req1.result >= 0); uv_fs_req_cleanup(&open_req1); - ASSERT_EQ(UV_EINVAL, uv_fs_read(NULL, &read_req, open_req1.result, - NULL, 0, 0, NULL)); - ASSERT_EQ(UV_EINVAL, uv_fs_read(NULL, &read_req, open_req1.result, - NULL, 1, 0, NULL)); - ASSERT_EQ(UV_EINVAL, uv_fs_read(NULL, &read_req, open_req1.result, - bufs, 0, 0, NULL)); + ASSERT(UV_EINVAL == uv_fs_read(NULL, &read_req, open_req1.result, + NULL, 0, 0, NULL)); + ASSERT(UV_EINVAL == uv_fs_read(NULL, &read_req, open_req1.result, + NULL, 1, 0, NULL)); + ASSERT(UV_EINVAL == uv_fs_read(NULL, &read_req, open_req1.result, + bufs, 0, 0, NULL)); bufs[0] = uv_buf_init(scratch + 0, 256); bufs[1] = uv_buf_init(scratch + 256, 256); bufs[2] = uv_buf_init(scratch + 512, 128); bufs[3] = uv_buf_init(scratch + 640, 128); - ASSERT_EQ(446, uv_fs_read(NULL, - &read_req, - open_req1.result, - bufs + 0, - 2, /* 2x 256 bytes. */ - 0, /* Positional read. */ - NULL)); - ASSERT_EQ(446, read_req.result); + ASSERT(446 == uv_fs_read(NULL, + &read_req, + open_req1.result, + bufs + 0, + 2, /* 2x 256 bytes. */ + 0, /* Positional read. */ + NULL)); + ASSERT(read_req.result == 446); uv_fs_req_cleanup(&read_req); - ASSERT_EQ(190, uv_fs_read(NULL, - &read_req, - open_req1.result, - bufs + 2, - 2, /* 2x 128 bytes. */ - 256, /* Positional read. */ - NULL)); - ASSERT_EQ(read_req.result, /* 446 - 256 */ 190); + ASSERT(190 == uv_fs_read(NULL, + &read_req, + open_req1.result, + bufs + 2, + 2, /* 2x 128 bytes. */ + 256, /* Positional read. */ + NULL)); + ASSERT(read_req.result == /* 446 - 256 */ 190); uv_fs_req_cleanup(&read_req); - ASSERT_OK(memcmp(bufs[1].base + 0, bufs[2].base, 128)); - ASSERT_OK(memcmp(bufs[1].base + 128, bufs[3].base, 190 - 128)); + ASSERT(0 == memcmp(bufs[1].base + 0, bufs[2].base, 128)); + ASSERT(0 == memcmp(bufs[1].base + 128, bufs[3].base, 190 - 128)); - ASSERT_OK(uv_fs_close(NULL, &close_req, open_req1.result, NULL)); - ASSERT_OK(close_req.result); + ASSERT(0 == uv_fs_close(NULL, &close_req, open_req1.result, NULL)); + ASSERT(close_req.result == 0); uv_fs_req_cleanup(&close_req); } TEST_IMPL(fs_read_bufs) { fs_read_bufs(0); fs_read_bufs(UV_FS_O_FILEMAP); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -3251,47 +3021,46 @@ static void fs_read_file_eof(int add_flags) { loop = uv_default_loop(); r = uv_fs_open(NULL, &open_req1, "test_file", - UV_FS_O_WRONLY | UV_FS_O_CREAT | add_flags, S_IWUSR | S_IRUSR, - NULL); - ASSERT_GE(r, 0); - ASSERT_GE(open_req1.result, 0); + O_WRONLY | O_CREAT | add_flags, S_IWUSR | S_IRUSR, NULL); + ASSERT(r >= 0); + ASSERT(open_req1.result >= 0); uv_fs_req_cleanup(&open_req1); iov = uv_buf_init(test_buf, sizeof(test_buf)); r = uv_fs_write(NULL, &write_req, open_req1.result, &iov, 1, -1, NULL); - ASSERT_GE(r, 0); - ASSERT_GE(write_req.result, 0); + ASSERT(r >= 0); + ASSERT(write_req.result >= 0); uv_fs_req_cleanup(&write_req); r = uv_fs_close(NULL, &close_req, open_req1.result, NULL); - ASSERT_OK(r); - ASSERT_OK(close_req.result); + ASSERT(r == 0); + ASSERT(close_req.result == 0); uv_fs_req_cleanup(&close_req); - r = uv_fs_open(NULL, &open_req1, "test_file", UV_FS_O_RDONLY | add_flags, 0, + r = uv_fs_open(NULL, &open_req1, "test_file", O_RDONLY | add_flags, 0, NULL); - ASSERT_GE(r, 0); - ASSERT_GE(open_req1.result, 0); + ASSERT(r >= 0); + ASSERT(open_req1.result >= 0); uv_fs_req_cleanup(&open_req1); memset(buf, 0, sizeof(buf)); iov = uv_buf_init(buf, sizeof(buf)); r = uv_fs_read(NULL, &read_req, open_req1.result, &iov, 1, -1, NULL); - ASSERT_GE(r, 0); - ASSERT_GE(read_req.result, 0); - ASSERT_OK(strcmp(buf, test_buf)); + ASSERT(r >= 0); + ASSERT(read_req.result >= 0); + ASSERT(strcmp(buf, test_buf) == 0); uv_fs_req_cleanup(&read_req); iov = uv_buf_init(buf, sizeof(buf)); r = uv_fs_read(NULL, &read_req, open_req1.result, &iov, 1, read_req.result, NULL); - ASSERT_OK(r); - ASSERT_OK(read_req.result); + ASSERT(r == 0); + ASSERT(read_req.result == 0); uv_fs_req_cleanup(&read_req); r = uv_fs_close(NULL, &close_req, open_req1.result, NULL); - ASSERT_OK(r); - ASSERT_OK(close_req.result); + ASSERT(r == 0); + ASSERT(close_req.result == 0); uv_fs_req_cleanup(&close_req); /* Cleanup */ @@ -3301,7 +3070,7 @@ TEST_IMPL(fs_read_file_eof) { fs_read_file_eof(0); fs_read_file_eof(UV_FS_O_FILEMAP); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -3316,28 +3085,27 @@ static void fs_write_multiple_bufs(int add_flags) { loop = uv_default_loop(); r = uv_fs_open(NULL, &open_req1, "test_file", - UV_FS_O_WRONLY | UV_FS_O_CREAT | add_flags, S_IWUSR | S_IRUSR, - NULL); - ASSERT_GE(r, 0); - ASSERT_GE(open_req1.result, 0); + O_WRONLY | O_CREAT | add_flags, S_IWUSR | S_IRUSR, NULL); + ASSERT(r >= 0); + ASSERT(open_req1.result >= 0); uv_fs_req_cleanup(&open_req1); iovs[0] = uv_buf_init(test_buf, sizeof(test_buf)); iovs[1] = uv_buf_init(test_buf2, sizeof(test_buf2)); r = uv_fs_write(NULL, &write_req, open_req1.result, iovs, 2, 0, NULL); - ASSERT_GE(r, 0); - ASSERT_GE(write_req.result, 0); + ASSERT(r >= 0); + ASSERT(write_req.result >= 0); uv_fs_req_cleanup(&write_req); r = uv_fs_close(NULL, &close_req, open_req1.result, NULL); - ASSERT_OK(r); - ASSERT_OK(close_req.result); + ASSERT(r == 0); + ASSERT(close_req.result == 0); uv_fs_req_cleanup(&close_req); - r = uv_fs_open(NULL, &open_req1, "test_file", UV_FS_O_RDONLY | add_flags, 0, + r = uv_fs_open(NULL, &open_req1, "test_file", O_RDONLY | add_flags, 0, NULL); - ASSERT_GE(r, 0); - ASSERT_GE(open_req1.result, 0); + ASSERT(r >= 0); + ASSERT(open_req1.result >= 0); uv_fs_req_cleanup(&open_req1); memset(buf, 0, sizeof(buf)); @@ -3345,48 +3113,48 @@ static void fs_write_multiple_bufs(int add_flags) { /* Read the strings back to separate buffers. */ iovs[0] = uv_buf_init(buf, sizeof(test_buf)); iovs[1] = uv_buf_init(buf2, sizeof(test_buf2)); - ASSERT_OK(lseek(open_req1.result, 0, SEEK_CUR)); + ASSERT(lseek(open_req1.result, 0, SEEK_CUR) == 0); r = uv_fs_read(NULL, &read_req, open_req1.result, iovs, 2, -1, NULL); - ASSERT_GE(r, 0); - ASSERT_EQ(read_req.result, sizeof(test_buf) + sizeof(test_buf2)); - ASSERT_OK(strcmp(buf, test_buf)); - ASSERT_OK(strcmp(buf2, test_buf2)); + ASSERT(r >= 0); + ASSERT(read_req.result == sizeof(test_buf) + sizeof(test_buf2)); + ASSERT(strcmp(buf, test_buf) == 0); + ASSERT(strcmp(buf2, test_buf2) == 0); uv_fs_req_cleanup(&read_req); iov = uv_buf_init(buf, sizeof(buf)); r = uv_fs_read(NULL, &read_req, open_req1.result, &iov, 1, -1, NULL); - ASSERT_OK(r); - ASSERT_OK(read_req.result); + ASSERT(r == 0); + ASSERT(read_req.result == 0); uv_fs_req_cleanup(&read_req); /* Read the strings back to separate buffers. */ iovs[0] = uv_buf_init(buf, sizeof(test_buf)); iovs[1] = uv_buf_init(buf2, sizeof(test_buf2)); r = uv_fs_read(NULL, &read_req, open_req1.result, iovs, 2, 0, NULL); - ASSERT_GE(r, 0); + ASSERT(r >= 0); if (read_req.result == sizeof(test_buf)) { /* Infer that preadv is not available. */ uv_fs_req_cleanup(&read_req); r = uv_fs_read(NULL, &read_req, open_req1.result, &iovs[1], 1, read_req.result, NULL); - ASSERT_GE(r, 0); - ASSERT_EQ(read_req.result, sizeof(test_buf2)); + ASSERT(r >= 0); + ASSERT(read_req.result == sizeof(test_buf2)); } else { - ASSERT_EQ(read_req.result, sizeof(test_buf) + sizeof(test_buf2)); + ASSERT(read_req.result == sizeof(test_buf) + sizeof(test_buf2)); } - ASSERT_OK(strcmp(buf, test_buf)); - ASSERT_OK(strcmp(buf2, test_buf2)); + ASSERT(strcmp(buf, test_buf) == 0); + ASSERT(strcmp(buf2, test_buf2) == 0); uv_fs_req_cleanup(&read_req); iov = uv_buf_init(buf, sizeof(buf)); r = uv_fs_read(NULL, &read_req, open_req1.result, &iov, 1, sizeof(test_buf) + sizeof(test_buf2), NULL); - ASSERT_OK(r); - ASSERT_OK(read_req.result); + ASSERT(r == 0); + ASSERT(read_req.result == 0); uv_fs_req_cleanup(&read_req); r = uv_fs_close(NULL, &close_req, open_req1.result, NULL); - ASSERT_OK(r); - ASSERT_OK(close_req.result); + ASSERT(r == 0); + ASSERT(close_req.result == 0); uv_fs_req_cleanup(&close_req); /* Cleanup */ @@ -3396,7 +3164,7 @@ TEST_IMPL(fs_write_multiple_bufs) { fs_write_multiple_bufs(0); fs_write_multiple_bufs(UV_FS_O_FILEMAP); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -3423,11 +3191,11 @@ static void fs_write_alotof_bufs(int add_flags) { r = uv_fs_open(NULL, &open_req1, "test_file", - UV_FS_O_RDWR | UV_FS_O_CREAT | add_flags, + O_RDWR | O_CREAT | add_flags, S_IWUSR | S_IRUSR, NULL); - ASSERT_GE(r, 0); - ASSERT_GE(open_req1.result, 0); + ASSERT(r >= 0); + ASSERT(open_req1.result >= 0); uv_fs_req_cleanup(&open_req1); for (index = 0; index < iovcount; ++index) @@ -3440,8 +3208,8 @@ static void fs_write_alotof_bufs(int add_flags) { iovcount, -1, NULL); - ASSERT_GE(r, 0); - ASSERT_EQ((size_t)write_req.result, sizeof(test_buf) * iovcount); + ASSERT(r >= 0); + ASSERT((size_t)write_req.result == sizeof(test_buf) * iovcount); uv_fs_req_cleanup(&write_req); /* Read the strings back to separate buffers. */ @@ -3453,32 +3221,31 @@ static void fs_write_alotof_bufs(int add_flags) { sizeof(test_buf)); r = uv_fs_close(NULL, &close_req, open_req1.result, NULL); - ASSERT_OK(r); - ASSERT_OK(close_req.result); + ASSERT(r == 0); + ASSERT(close_req.result == 0); uv_fs_req_cleanup(&close_req); - r = uv_fs_open(NULL, &open_req1, "test_file", UV_FS_O_RDONLY | add_flags, 0, + r = uv_fs_open(NULL, &open_req1, "test_file", O_RDONLY | add_flags, 0, NULL); - ASSERT_GE(r, 0); - ASSERT_GE(open_req1.result, 0); + ASSERT(r >= 0); + ASSERT(open_req1.result >= 0); uv_fs_req_cleanup(&open_req1); r = uv_fs_read(NULL, &read_req, open_req1.result, iovs, iovcount, -1, NULL); if (iovcount > iovmax) iovcount = iovmax; - ASSERT_GE(r, 0); - ASSERT_EQ((size_t)read_req.result, sizeof(test_buf) * iovcount); + ASSERT(r >= 0); + ASSERT((size_t)read_req.result == sizeof(test_buf) * iovcount); for (index = 0; index < iovcount; ++index) - ASSERT_OK(strncmp(buffer + index * sizeof(test_buf), - test_buf, - sizeof(test_buf))); + ASSERT(strncmp(buffer + index * sizeof(test_buf), + test_buf, + sizeof(test_buf)) == 0); uv_fs_req_cleanup(&read_req); free(buffer); - ASSERT_EQ(lseek(open_req1.result, write_req.result, SEEK_SET), - write_req.result); + ASSERT(lseek(open_req1.result, write_req.result, SEEK_SET) == write_req.result); iov = uv_buf_init(buf, sizeof(buf)); r = uv_fs_read(NULL, &read_req, @@ -3487,13 +3254,13 @@ static void fs_write_alotof_bufs(int add_flags) { 1, -1, NULL); - ASSERT_OK(r); - ASSERT_OK(read_req.result); + ASSERT(r == 0); + ASSERT(read_req.result == 0); uv_fs_req_cleanup(&read_req); r = uv_fs_close(NULL, &close_req, open_req1.result, NULL); - ASSERT_OK(r); - ASSERT_OK(close_req.result); + ASSERT(r == 0); + ASSERT(close_req.result == 0); uv_fs_req_cleanup(&close_req); /* Cleanup */ @@ -3504,7 +3271,7 @@ TEST_IMPL(fs_write_alotof_bufs) { fs_write_alotof_bufs(0); fs_write_alotof_bufs(UV_FS_O_FILEMAP); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -3536,17 +3303,17 @@ static void fs_write_alotof_bufs_with_offset(int add_flags) { r = uv_fs_open(NULL, &open_req1, "test_file", - UV_FS_O_RDWR | UV_FS_O_CREAT | add_flags, + O_RDWR | O_CREAT | add_flags, S_IWUSR | S_IRUSR, NULL); - ASSERT_GE(r, 0); - ASSERT_GE(open_req1.result, 0); + ASSERT(r >= 0); + ASSERT(open_req1.result >= 0); uv_fs_req_cleanup(&open_req1); iov = uv_buf_init(filler, filler_len); r = uv_fs_write(NULL, &write_req, open_req1.result, &iov, 1, -1, NULL); - ASSERT_EQ(r, filler_len); - ASSERT_EQ(write_req.result, filler_len); + ASSERT(r == filler_len); + ASSERT(write_req.result == filler_len); uv_fs_req_cleanup(&write_req); offset = (int64_t)r; @@ -3560,8 +3327,8 @@ static void fs_write_alotof_bufs_with_offset(int add_flags) { iovcount, offset, NULL); - ASSERT_GE(r, 0); - ASSERT_EQ((size_t)write_req.result, sizeof(test_buf) * iovcount); + ASSERT(r >= 0); + ASSERT((size_t)write_req.result == sizeof(test_buf) * iovcount); uv_fs_req_cleanup(&write_req); /* Read the strings back to separate buffers. */ @@ -3574,25 +3341,25 @@ static void fs_write_alotof_bufs_with_offset(int add_flags) { r = uv_fs_read(NULL, &read_req, open_req1.result, iovs, iovcount, offset, NULL); - ASSERT_GE(r, 0); + ASSERT(r >= 0); if (r == sizeof(test_buf)) iovcount = 1; /* Infer that preadv is not available. */ else if (iovcount > iovmax) iovcount = iovmax; - ASSERT_EQ((size_t)read_req.result, sizeof(test_buf) * iovcount); + ASSERT((size_t)read_req.result == sizeof(test_buf) * iovcount); for (index = 0; index < iovcount; ++index) - ASSERT_OK(strncmp(buffer + index * sizeof(test_buf), - test_buf, - sizeof(test_buf))); + ASSERT(strncmp(buffer + index * sizeof(test_buf), + test_buf, + sizeof(test_buf)) == 0); uv_fs_req_cleanup(&read_req); free(buffer); r = uv_fs_stat(NULL, &stat_req, "test_file", NULL); - ASSERT_OK(r); - ASSERT_EQ((int64_t)((uv_stat_t*)stat_req.ptr)->st_size, - offset + (int64_t)write_req.result); + ASSERT(r == 0); + ASSERT((int64_t)((uv_stat_t*)stat_req.ptr)->st_size == + offset + (int64_t)write_req.result); uv_fs_req_cleanup(&stat_req); iov = uv_buf_init(buf, sizeof(buf)); @@ -3603,13 +3370,13 @@ static void fs_write_alotof_bufs_with_offset(int add_flags) { 1, offset + write_req.result, NULL); - ASSERT_OK(r); - ASSERT_OK(read_req.result); + ASSERT(r == 0); + ASSERT(read_req.result == 0); uv_fs_req_cleanup(&read_req); r = uv_fs_close(NULL, &close_req, open_req1.result, NULL); - ASSERT_OK(r); - ASSERT_OK(close_req.result); + ASSERT(r == 0); + ASSERT(close_req.result == 0); uv_fs_req_cleanup(&close_req); /* Cleanup */ @@ -3620,7 +3387,7 @@ TEST_IMPL(fs_write_alotof_bufs_with_offset) { fs_write_alotof_bufs_with_offset(0); fs_write_alotof_bufs_with_offset(UV_FS_O_FILEMAP); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -3632,9 +3399,9 @@ TEST_IMPL(fs_read_dir) { /* Setup */ rmdir("test_dir"); r = uv_fs_mkdir(loop, &mkdir_req, "test_dir", 0755, mkdir_cb); - ASSERT_OK(r); + ASSERT(r == 0); uv_run(loop, UV_RUN_DEFAULT); - ASSERT_EQ(1, mkdir_cb_count); + ASSERT(mkdir_cb_count == 1); /* Setup Done Here */ /* Get a file descriptor for the directory */ @@ -3644,7 +3411,7 @@ TEST_IMPL(fs_read_dir) { UV_FS_O_RDONLY | UV_FS_O_DIRECTORY, S_IWUSR | S_IRUSR, NULL); - ASSERT_GE(r, 0); + ASSERT(r >= 0); uv_fs_req_cleanup(&open_req1); /* Try to read data from the directory */ @@ -3664,18 +3431,18 @@ TEST_IMPL(fs_read_dir) { */ ASSERT((r >= 0) || (r == UV_EISDIR)); #else - ASSERT_EQ(r, UV_EISDIR); + ASSERT(r == UV_EISDIR); #endif uv_fs_req_cleanup(&read_req); r = uv_fs_close(NULL, &close_req, open_req1.result, NULL); - ASSERT_OK(r); + ASSERT(r == 0); uv_fs_req_cleanup(&close_req); /* Cleanup */ rmdir("test_dir"); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -3716,7 +3483,7 @@ static void thread_main(void* arg) { if (ctx->doread) { result = write(ctx->fd, data, nbytes); /* Should not see EINTR (or other errors) */ - ASSERT_EQ(result, nbytes); + ASSERT(result == nbytes); } else { result = read(ctx->fd, data, nbytes); /* Should not see EINTR (or other errors), @@ -3768,9 +3535,9 @@ static void test_fs_partial(int doread) { ctx.doread = doread; ctx.interval = 1000; ctx.size = sizeof(test_buf) * iovcount; - ctx.data = calloc(ctx.size, 1); + ctx.data = malloc(ctx.size); ASSERT_NOT_NULL(ctx.data); - buffer = calloc(ctx.size, 1); + buffer = malloc(ctx.size); ASSERT_NOT_NULL(buffer); for (index = 0; index < iovcount; ++index) @@ -3778,13 +3545,13 @@ static void test_fs_partial(int doread) { loop = uv_default_loop(); - ASSERT_OK(uv_signal_init(loop, &signal)); - ASSERT_OK(uv_signal_start(&signal, sig_func, SIGUSR1)); + ASSERT(0 == uv_signal_init(loop, &signal)); + ASSERT(0 == uv_signal_start(&signal, sig_func, SIGUSR1)); - ASSERT_OK(pipe(pipe_fds)); + ASSERT(0 == pipe(pipe_fds)); ctx.fd = pipe_fds[doread]; - ASSERT_OK(uv_thread_create(&thread, thread_main, &ctx)); + ASSERT(0 == uv_thread_create(&thread, thread_main, &ctx)); if (doread) { uv_buf_t* read_iovs; @@ -3801,40 +3568,39 @@ static void test_fs_partial(int doread) { iovcount -= read_iovcount; nread += result; } else { - ASSERT_EQ(result, UV_EINTR); + ASSERT(result == UV_EINTR); } uv_fs_req_cleanup(&read_req); } } else { int result; result = uv_fs_write(loop, &write_req, pipe_fds[1], iovs, iovcount, -1, NULL); - ASSERT_EQ(write_req.result, result); - ASSERT_EQ(result, ctx.size); + ASSERT(write_req.result == result); + ASSERT(result == ctx.size); uv_fs_req_cleanup(&write_req); } - ASSERT_OK(uv_thread_join(&thread)); - - ASSERT_MEM_EQ(buffer, ctx.data, ctx.size); + ASSERT(0 == memcmp(buffer, ctx.data, ctx.size)); - ASSERT_OK(uv_run(loop, UV_RUN_DEFAULT)); + ASSERT(0 == uv_thread_join(&thread)); + ASSERT(0 == uv_run(loop, UV_RUN_DEFAULT)); - ASSERT_OK(close(pipe_fds[1])); + ASSERT(0 == close(pipe_fds[1])); uv_close((uv_handle_t*) &signal, NULL); { /* Make sure we read everything that we wrote. */ int result; result = uv_fs_read(loop, &read_req, pipe_fds[0], iovs, 1, -1, NULL); - ASSERT_OK(result); + ASSERT(result == 0); uv_fs_req_cleanup(&read_req); } - ASSERT_OK(close(pipe_fds[0])); + ASSERT(0 == close(pipe_fds[0])); free(iovs); free(buffer); free(ctx.data); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); } TEST_IMPL(fs_partial_read) { @@ -3853,13 +3619,13 @@ TEST_IMPL(fs_read_write_null_arguments) { int r; r = uv_fs_read(NULL, &read_req, 0, NULL, 0, -1, NULL); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); uv_fs_req_cleanup(&read_req); r = uv_fs_write(NULL, &write_req, 0, NULL, 0, -1, NULL); /* Validate some memory management on failed input validation before sending fs work to the thread pool. */ - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); ASSERT_NULL(write_req.path); ASSERT_NULL(write_req.ptr); #ifdef _WIN32 @@ -3874,40 +3640,39 @@ TEST_IMPL(fs_read_write_null_arguments) { iov = uv_buf_init(NULL, 0); r = uv_fs_read(NULL, &read_req, 0, &iov, 0, -1, NULL); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); uv_fs_req_cleanup(&read_req); iov = uv_buf_init(NULL, 0); r = uv_fs_write(NULL, &write_req, 0, &iov, 0, -1, NULL); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); uv_fs_req_cleanup(&write_req); /* If the arguments are invalid, the loop should not be kept open */ loop = uv_default_loop(); r = uv_fs_read(loop, &read_req, 0, NULL, 0, -1, fail_cb); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); uv_run(loop, UV_RUN_DEFAULT); uv_fs_req_cleanup(&read_req); r = uv_fs_write(loop, &write_req, 0, NULL, 0, -1, fail_cb); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); uv_run(loop, UV_RUN_DEFAULT); uv_fs_req_cleanup(&write_req); iov = uv_buf_init(NULL, 0); r = uv_fs_read(loop, &read_req, 0, &iov, 0, -1, fail_cb); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); uv_run(loop, UV_RUN_DEFAULT); uv_fs_req_cleanup(&read_req); iov = uv_buf_init(NULL, 0); r = uv_fs_write(loop, &write_req, 0, &iov, 0, -1, fail_cb); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); uv_run(loop, UV_RUN_DEFAULT); uv_fs_req_cleanup(&write_req); - MAKE_VALGRIND_HAPPY(loop); return 0; } @@ -3922,29 +3687,31 @@ TEST_IMPL(get_osfhandle_valid_handle) { loop = uv_default_loop(); r = uv_fs_open(NULL, - &open_req1, "test_file", UV_FS_O_RDWR | UV_FS_O_CREAT, + &open_req1, + "test_file", + O_RDWR | O_CREAT, S_IWUSR | S_IRUSR, NULL); - ASSERT_GE(r, 0); - ASSERT_GE(open_req1.result, 0); + ASSERT(r >= 0); + ASSERT(open_req1.result >= 0); uv_fs_req_cleanup(&open_req1); fd = uv_get_osfhandle(open_req1.result); #ifdef _WIN32 - ASSERT_PTR_NE(fd, INVALID_HANDLE_VALUE); + ASSERT(fd != INVALID_HANDLE_VALUE); #else - ASSERT_GE(fd, 0); + ASSERT(fd >= 0); #endif r = uv_fs_close(NULL, &close_req, open_req1.result, NULL); - ASSERT_OK(r); - ASSERT_OK(close_req.result); + ASSERT(r == 0); + ASSERT(close_req.result == 0); uv_fs_req_cleanup(&close_req); /* Cleanup. */ unlink("test_file"); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -3961,36 +3728,36 @@ TEST_IMPL(open_osfhandle_valid_handle) { r = uv_fs_open(NULL, &open_req1, "test_file", - UV_FS_O_RDWR | UV_FS_O_CREAT, + O_RDWR | O_CREAT, S_IWUSR | S_IRUSR, NULL); - ASSERT_GE(r, 0); - ASSERT_GE(open_req1.result, 0); + ASSERT(r >= 0); + ASSERT(open_req1.result >= 0); uv_fs_req_cleanup(&open_req1); handle = uv_get_osfhandle(open_req1.result); #ifdef _WIN32 - ASSERT_PTR_NE(handle, INVALID_HANDLE_VALUE); + ASSERT(handle != INVALID_HANDLE_VALUE); #else - ASSERT_GE(handle, 0); + ASSERT(handle >= 0); #endif fd = uv_open_osfhandle(handle); #ifdef _WIN32 - ASSERT_GT(fd, 0); + ASSERT(fd > 0); #else - ASSERT_EQ(fd, open_req1.result); + ASSERT(fd == open_req1.result); #endif r = uv_fs_close(NULL, &close_req, open_req1.result, NULL); - ASSERT_OK(r); - ASSERT_OK(close_req.result); + ASSERT(r == 0); + ASSERT(close_req.result == 0); uv_fs_req_cleanup(&close_req); /* Cleanup. */ unlink("test_file"); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -4002,33 +3769,35 @@ TEST_IMPL(fs_file_pos_after_op_with_offset) { loop = uv_default_loop(); r = uv_fs_open(loop, - &open_req1, "test_file", UV_FS_O_RDWR | UV_FS_O_CREAT, + &open_req1, + "test_file", + O_RDWR | O_CREAT, S_IWUSR | S_IRUSR, NULL); - ASSERT_GT(r, 0); + ASSERT(r > 0); uv_fs_req_cleanup(&open_req1); iov = uv_buf_init(test_buf, sizeof(test_buf)); r = uv_fs_write(NULL, &write_req, open_req1.result, &iov, 1, 0, NULL); - ASSERT_EQ(r, sizeof(test_buf)); - ASSERT_OK(lseek(open_req1.result, 0, SEEK_CUR)); + ASSERT(r == sizeof(test_buf)); + ASSERT(lseek(open_req1.result, 0, SEEK_CUR) == 0); uv_fs_req_cleanup(&write_req); iov = uv_buf_init(buf, sizeof(buf)); r = uv_fs_read(NULL, &read_req, open_req1.result, &iov, 1, 0, NULL); - ASSERT_EQ(r, sizeof(test_buf)); - ASSERT_OK(strcmp(buf, test_buf)); - ASSERT_OK(lseek(open_req1.result, 0, SEEK_CUR)); + ASSERT(r == sizeof(test_buf)); + ASSERT(strcmp(buf, test_buf) == 0); + ASSERT(lseek(open_req1.result, 0, SEEK_CUR) == 0); uv_fs_req_cleanup(&read_req); r = uv_fs_close(NULL, &close_req, open_req1.result, NULL); - ASSERT_OK(r); + ASSERT(r == 0); uv_fs_req_cleanup(&close_req); /* Cleanup */ unlink("test_file"); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -4038,30 +3807,30 @@ static void fs_file_pos_common(void) { iov = uv_buf_init("abc", 3); r = uv_fs_write(NULL, &write_req, open_req1.result, &iov, 1, -1, NULL); - ASSERT_EQ(3, r); + ASSERT(r == 3); uv_fs_req_cleanup(&write_req); /* Read with offset should not change the position */ iov = uv_buf_init(buf, 1); r = uv_fs_read(NULL, &read_req, open_req1.result, &iov, 1, 1, NULL); - ASSERT_EQ(1, r); - ASSERT_EQ(buf[0], 'b'); + ASSERT(r == 1); + ASSERT(buf[0] == 'b'); uv_fs_req_cleanup(&read_req); iov = uv_buf_init(buf, sizeof(buf)); r = uv_fs_read(NULL, &read_req, open_req1.result, &iov, 1, -1, NULL); - ASSERT_OK(r); + ASSERT(r == 0); uv_fs_req_cleanup(&read_req); /* Write without offset should change the position */ iov = uv_buf_init("d", 1); r = uv_fs_write(NULL, &write_req, open_req1.result, &iov, 1, -1, NULL); - ASSERT_EQ(1, r); + ASSERT(r == 1); uv_fs_req_cleanup(&write_req); iov = uv_buf_init(buf, sizeof(buf)); r = uv_fs_read(NULL, &read_req, open_req1.result, &iov, 1, -1, NULL); - ASSERT_OK(r); + ASSERT(r == 0); uv_fs_req_cleanup(&read_req); } @@ -4070,23 +3839,23 @@ static void fs_file_pos_close_check(const char *contents, int size) { /* Close */ r = uv_fs_close(NULL, &close_req, open_req1.result, NULL); - ASSERT_OK(r); + ASSERT(r == 0); uv_fs_req_cleanup(&close_req); /* Confirm file contents */ - r = uv_fs_open(NULL, &open_req1, "test_file", UV_FS_O_RDONLY, 0, NULL); - ASSERT_GE(r, 0); - ASSERT_GE(open_req1.result, 0); + r = uv_fs_open(NULL, &open_req1, "test_file", O_RDONLY, 0, NULL); + ASSERT(r >= 0); + ASSERT(open_req1.result >= 0); uv_fs_req_cleanup(&open_req1); iov = uv_buf_init(buf, sizeof(buf)); r = uv_fs_read(NULL, &read_req, open_req1.result, &iov, 1, -1, NULL); - ASSERT_EQ(r, size); - ASSERT_OK(strncmp(buf, contents, size)); + ASSERT(r == size); + ASSERT(strncmp(buf, contents, size) == 0); uv_fs_req_cleanup(&read_req); r = uv_fs_close(NULL, &close_req, open_req1.result, NULL); - ASSERT_OK(r); + ASSERT(r == 0); uv_fs_req_cleanup(&close_req); /* Cleanup */ @@ -4102,10 +3871,10 @@ static void fs_file_pos_write(int add_flags) { r = uv_fs_open(NULL, &open_req1, "test_file", - UV_FS_O_TRUNC | UV_FS_O_CREAT | UV_FS_O_RDWR | add_flags, + O_TRUNC | O_CREAT | O_RDWR | add_flags, S_IWUSR | S_IRUSR, NULL); - ASSERT_GT(r, 0); + ASSERT(r > 0); uv_fs_req_cleanup(&open_req1); fs_file_pos_common(); @@ -4113,12 +3882,12 @@ static void fs_file_pos_write(int add_flags) { /* Write with offset should not change the position */ iov = uv_buf_init("e", 1); r = uv_fs_write(NULL, &write_req, open_req1.result, &iov, 1, 1, NULL); - ASSERT_EQ(1, r); + ASSERT(r == 1); uv_fs_req_cleanup(&write_req); iov = uv_buf_init(buf, sizeof(buf)); r = uv_fs_read(NULL, &read_req, open_req1.result, &iov, 1, -1, NULL); - ASSERT_OK(r); + ASSERT(r == 0); uv_fs_req_cleanup(&read_req); fs_file_pos_close_check("aecd", 4); @@ -4127,7 +3896,7 @@ TEST_IMPL(fs_file_pos_write) { fs_file_pos_write(0); fs_file_pos_write(UV_FS_O_FILEMAP); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -4140,10 +3909,10 @@ static void fs_file_pos_append(int add_flags) { r = uv_fs_open(NULL, &open_req1, "test_file", - UV_FS_O_APPEND | UV_FS_O_CREAT | UV_FS_O_RDWR | add_flags, + O_APPEND | O_CREAT | O_RDWR | add_flags, S_IWUSR | S_IRUSR, NULL); - ASSERT_GT(r, 0); + ASSERT(r > 0); uv_fs_req_cleanup(&open_req1); fs_file_pos_common(); @@ -4152,13 +3921,13 @@ static void fs_file_pos_append(int add_flags) { * but does not change the position */ iov = uv_buf_init("e", 1); r = uv_fs_write(NULL, &write_req, open_req1.result, &iov, 1, 1, NULL); - ASSERT_EQ(1, r); + ASSERT(r == 1); uv_fs_req_cleanup(&write_req); iov = uv_buf_init(buf, sizeof(buf)); r = uv_fs_read(NULL, &read_req, open_req1.result, &iov, 1, -1, NULL); - ASSERT_EQ(1, r); - ASSERT_EQ(buf[0], 'e'); + ASSERT(r == 1); + ASSERT(buf[0] == 'e'); uv_fs_req_cleanup(&read_req); fs_file_pos_close_check("abcde", 5); @@ -4167,7 +3936,7 @@ TEST_IMPL(fs_file_pos_append) { fs_file_pos_append(0); fs_file_pos_append(UV_FS_O_FILEMAP); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } #endif @@ -4177,97 +3946,97 @@ TEST_IMPL(fs_null_req) { int r; r = uv_fs_open(NULL, NULL, NULL, 0, 0, NULL); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); r = uv_fs_close(NULL, NULL, 0, NULL); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); r = uv_fs_read(NULL, NULL, 0, NULL, 0, -1, NULL); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); r = uv_fs_write(NULL, NULL, 0, NULL, 0, -1, NULL); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); r = uv_fs_unlink(NULL, NULL, NULL, NULL); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); r = uv_fs_mkdir(NULL, NULL, NULL, 0, NULL); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); r = uv_fs_mkdtemp(NULL, NULL, NULL, NULL); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); r = uv_fs_mkstemp(NULL, NULL, NULL, NULL); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); r = uv_fs_rmdir(NULL, NULL, NULL, NULL); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); r = uv_fs_scandir(NULL, NULL, NULL, 0, NULL); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); r = uv_fs_link(NULL, NULL, NULL, NULL, NULL); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); r = uv_fs_symlink(NULL, NULL, NULL, NULL, 0, NULL); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); r = uv_fs_readlink(NULL, NULL, NULL, NULL); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); r = uv_fs_realpath(NULL, NULL, NULL, NULL); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); r = uv_fs_chown(NULL, NULL, NULL, 0, 0, NULL); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); r = uv_fs_fchown(NULL, NULL, 0, 0, 0, NULL); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); r = uv_fs_stat(NULL, NULL, NULL, NULL); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); r = uv_fs_lstat(NULL, NULL, NULL, NULL); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); r = uv_fs_fstat(NULL, NULL, 0, NULL); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); r = uv_fs_rename(NULL, NULL, NULL, NULL, NULL); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); r = uv_fs_fsync(NULL, NULL, 0, NULL); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); r = uv_fs_fdatasync(NULL, NULL, 0, NULL); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); r = uv_fs_ftruncate(NULL, NULL, 0, 0, NULL); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); r = uv_fs_copyfile(NULL, NULL, NULL, NULL, 0, NULL); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); r = uv_fs_sendfile(NULL, NULL, 0, 0, 0, 0, NULL); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); r = uv_fs_access(NULL, NULL, NULL, 0, NULL); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); r = uv_fs_chmod(NULL, NULL, NULL, 0, NULL); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); r = uv_fs_fchmod(NULL, NULL, 0, 0, NULL); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); r = uv_fs_utime(NULL, NULL, NULL, 0.0, 0.0, NULL); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); r = uv_fs_futime(NULL, NULL, 0, 0.0, 0.0, NULL); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); r = uv_fs_statfs(NULL, NULL, NULL, NULL); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); /* This should be a no-op. */ uv_fs_req_cleanup(NULL); @@ -4282,50 +4051,52 @@ TEST_IMPL(fs_exclusive_sharing_mode) { /* Setup. */ unlink("test_file"); - ASSERT_GT(UV_FS_O_EXLOCK, 0); + ASSERT(UV_FS_O_EXLOCK > 0); r = uv_fs_open(NULL, &open_req1, "test_file", - UV_FS_O_RDWR | UV_FS_O_CREAT | UV_FS_O_EXLOCK, + O_RDWR | O_CREAT | UV_FS_O_EXLOCK, S_IWUSR | S_IRUSR, NULL); - ASSERT_GE(r, 0); - ASSERT_GE(open_req1.result, 0); + ASSERT(r >= 0); + ASSERT(open_req1.result >= 0); uv_fs_req_cleanup(&open_req1); r = uv_fs_open(NULL, &open_req2, - "test_file", UV_FS_O_RDONLY | UV_FS_O_EXLOCK, + "test_file", + O_RDONLY | UV_FS_O_EXLOCK, S_IWUSR | S_IRUSR, NULL); - ASSERT_LT(r, 0); - ASSERT_LT(open_req2.result, 0); + ASSERT(r < 0); + ASSERT(open_req2.result < 0); uv_fs_req_cleanup(&open_req2); r = uv_fs_close(NULL, &close_req, open_req1.result, NULL); - ASSERT_OK(r); - ASSERT_OK(close_req.result); + ASSERT(r == 0); + ASSERT(close_req.result == 0); uv_fs_req_cleanup(&close_req); r = uv_fs_open(NULL, &open_req2, - "test_file", UV_FS_O_RDONLY | UV_FS_O_EXLOCK, + "test_file", + O_RDONLY | UV_FS_O_EXLOCK, S_IWUSR | S_IRUSR, NULL); - ASSERT_GE(r, 0); - ASSERT_GE(open_req2.result, 0); + ASSERT(r >= 0); + ASSERT(open_req2.result >= 0); uv_fs_req_cleanup(&open_req2); r = uv_fs_close(NULL, &close_req, open_req2.result, NULL); - ASSERT_OK(r); - ASSERT_OK(close_req.result); + ASSERT(r == 0); + ASSERT(close_req.result == 0); uv_fs_req_cleanup(&close_req); /* Cleanup */ unlink("test_file"); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } #endif @@ -4337,10 +4108,10 @@ TEST_IMPL(fs_file_flag_no_buffering) { /* Setup. */ unlink("test_file"); - ASSERT_GT(UV_FS_O_APPEND, 0); - ASSERT_GT(UV_FS_O_CREAT, 0); - ASSERT_GT(UV_FS_O_DIRECT, 0); - ASSERT_GT(UV_FS_O_RDWR, 0); + ASSERT(UV_FS_O_APPEND > 0); + ASSERT(UV_FS_O_CREAT > 0); + ASSERT(UV_FS_O_DIRECT > 0); + ASSERT(UV_FS_O_RDWR > 0); /* FILE_APPEND_DATA must be excluded from FILE_GENERIC_WRITE: */ r = uv_fs_open(NULL, @@ -4349,13 +4120,13 @@ TEST_IMPL(fs_file_flag_no_buffering) { UV_FS_O_RDWR | UV_FS_O_CREAT | UV_FS_O_DIRECT, S_IWUSR | S_IRUSR, NULL); - ASSERT_GE(r, 0); - ASSERT_GE(open_req1.result, 0); + ASSERT(r >= 0); + ASSERT(open_req1.result >= 0); uv_fs_req_cleanup(&open_req1); r = uv_fs_close(NULL, &close_req, open_req1.result, NULL); - ASSERT_OK(r); - ASSERT_OK(close_req.result); + ASSERT(r == 0); + ASSERT(close_req.result == 0); uv_fs_req_cleanup(&close_req); /* FILE_APPEND_DATA and FILE_FLAG_NO_BUFFERING are mutually exclusive: */ @@ -4365,14 +4136,14 @@ TEST_IMPL(fs_file_flag_no_buffering) { UV_FS_O_APPEND | UV_FS_O_DIRECT, S_IWUSR | S_IRUSR, NULL); - ASSERT_EQ(r, UV_EINVAL); - ASSERT_EQ(open_req2.result, UV_EINVAL); + ASSERT(r == UV_EINVAL); + ASSERT(open_req2.result == UV_EINVAL); uv_fs_req_cleanup(&open_req2); /* Cleanup */ unlink("test_file"); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } #endif @@ -4407,7 +4178,7 @@ TEST_IMPL(fs_open_readonly_acl) { /* Setup - clear the ACL and remove the file */ loop = uv_default_loop(); r = uv_os_get_passwd(&pwd); - ASSERT_OK(r); + ASSERT(r == 0); call_icacls("icacls test_file_icacls /remove \"%s\" /inheritance:e", pwd.username); uv_fs_chmod(loop, &req, "test_file_icacls", S_IWUSR, NULL); @@ -4417,15 +4188,15 @@ TEST_IMPL(fs_open_readonly_acl) { r = uv_fs_open(loop, &open_req1, "test_file_icacls", - UV_FS_O_RDONLY | UV_FS_O_CREAT, + O_RDONLY | O_CREAT, S_IRUSR, NULL); - ASSERT_GE(r, 0); - ASSERT_GE(open_req1.result, 0); + ASSERT(r >= 0); + ASSERT(open_req1.result >= 0); uv_fs_req_cleanup(&open_req1); r = uv_fs_close(NULL, &close_req, open_req1.result, NULL); - ASSERT_OK(r); - ASSERT_OK(close_req.result); + ASSERT(r == 0); + ASSERT(close_req.result == 0); uv_fs_req_cleanup(&close_req); /* Set up ACL */ @@ -4440,8 +4211,7 @@ TEST_IMPL(fs_open_readonly_acl) { } /* Try opening the file */ - r = uv_fs_open(NULL, &open_req1, "test_file_icacls", UV_FS_O_RDONLY, 0, - NULL); + r = uv_fs_open(NULL, &open_req1, "test_file_icacls", O_RDONLY, 0, NULL); if (r < 0) { goto acl_cleanup; } @@ -4458,8 +4228,8 @@ TEST_IMPL(fs_open_readonly_acl) { pwd.username); unlink("test_file_icacls"); uv_os_free_passwd(&pwd); - ASSERT_OK(r); - MAKE_VALGRIND_HAPPY(loop); + ASSERT(r == 0); + MAKE_VALGRIND_HAPPY(); return 0; } #endif @@ -4474,38 +4244,40 @@ TEST_IMPL(fs_fchmod_archive_readonly) { /* Setup*/ unlink("test_file"); r = uv_fs_open(NULL, - &req, "test_file", UV_FS_O_WRONLY | UV_FS_O_CREAT, + &req, + "test_file", + O_WRONLY | O_CREAT, S_IWUSR | S_IRUSR, NULL); - ASSERT_GE(r, 0); - ASSERT_GE(req.result, 0); + ASSERT(r >= 0); + ASSERT(req.result >= 0); file = req.result; uv_fs_req_cleanup(&req); r = uv_fs_close(NULL, &req, file, NULL); - ASSERT_OK(r); + ASSERT(r == 0); uv_fs_req_cleanup(&req); /* Make the file read-only and clear archive flag */ r = SetFileAttributes("test_file", FILE_ATTRIBUTE_READONLY); - ASSERT(r); + ASSERT(r != 0); check_permission("test_file", 0400); /* Try fchmod */ - r = uv_fs_open(NULL, &req, "test_file", UV_FS_O_RDONLY, 0, NULL); - ASSERT_GE(r, 0); - ASSERT_GE(req.result, 0); + r = uv_fs_open(NULL, &req, "test_file", O_RDONLY, 0, NULL); + ASSERT(r >= 0); + ASSERT(req.result >= 0); file = req.result; uv_fs_req_cleanup(&req); r = uv_fs_fchmod(NULL, &req, file, S_IWUSR, NULL); - ASSERT_OK(r); - ASSERT_OK(req.result); + ASSERT(r == 0); + ASSERT(req.result == 0); uv_fs_req_cleanup(&req); r = uv_fs_close(NULL, &req, file, NULL); - ASSERT_OK(r); + ASSERT(r == 0); uv_fs_req_cleanup(&req); check_permission("test_file", S_IWUSR); /* Restore Archive flag for rest of the tests */ r = SetFileAttributes("test_file", FILE_ATTRIBUTE_ARCHIVE); - ASSERT(r); + ASSERT(r != 0); return 0; } @@ -4517,7 +4289,7 @@ TEST_IMPL(fs_invalid_mkdir_name) { loop = uv_default_loop(); r = uv_fs_mkdir(loop, &req, "invalid>", 0, NULL); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); ASSERT_EQ(UV_EINVAL, uv_fs_mkdir(loop, &req, "test:lol", 0, NULL)); return 0; @@ -4532,17 +4304,16 @@ TEST_IMPL(fs_statfs) { /* Test the synchronous version. */ r = uv_fs_statfs(NULL, &req, ".", NULL); - ASSERT_OK(r); + ASSERT(r == 0); statfs_cb(&req); - ASSERT_EQ(1, statfs_cb_count); + ASSERT(statfs_cb_count == 1); /* Test the asynchronous version. */ r = uv_fs_statfs(loop, &req, ".", statfs_cb); - ASSERT_OK(r); + ASSERT(r == 0); uv_run(loop, UV_RUN_DEFAULT); - ASSERT_EQ(2, statfs_cb_count); + ASSERT(statfs_cb_count == 2); - MAKE_VALGRIND_HAPPY(loop); return 0; } @@ -4552,91 +4323,14 @@ TEST_IMPL(fs_get_system_error) { int system_error; r = uv_fs_statfs(NULL, &req, "non_existing_file", NULL); - ASSERT(r); + ASSERT(r != 0); system_error = uv_fs_get_system_error(&req); #ifdef _WIN32 - ASSERT_EQ(system_error, ERROR_FILE_NOT_FOUND); + ASSERT(system_error == ERROR_FILE_NOT_FOUND); #else - ASSERT_EQ(system_error, ENOENT); + ASSERT(system_error == ENOENT); #endif return 0; } - - -TEST_IMPL(fs_stat_batch_multiple) { - uv_fs_t req[300]; - int r; - int i; - - rmdir("test_dir"); - - r = uv_fs_mkdir(NULL, &mkdir_req, "test_dir", 0755, NULL); - ASSERT_OK(r); - - loop = uv_default_loop(); - - for (i = 0; i < (int) ARRAY_SIZE(req); ++i) { - r = uv_fs_stat(loop, &req[i], "test_dir", stat_batch_cb); - ASSERT_OK(r); - } - - uv_run(loop, UV_RUN_DEFAULT); - ASSERT_EQ(stat_cb_count, ARRAY_SIZE(req)); - - MAKE_VALGRIND_HAPPY(loop); - return 0; -} - - -#ifdef _WIN32 -TEST_IMPL(fs_wtf) { - int r; - HANDLE file_handle; - uv_dirent_t dent; - static char test_file_buf[PATHMAX]; - - /* set-up */ - _wunlink(L"test_dir/hi\xD801\x0037"); - rmdir("test_dir"); - - loop = uv_default_loop(); - - r = uv_fs_mkdir(NULL, &mkdir_req, "test_dir", 0777, NULL); - ASSERT_OK(r); - uv_fs_req_cleanup(&mkdir_req); - - file_handle = CreateFileW(L"test_dir/hi\xD801\x0037", - GENERIC_WRITE | FILE_WRITE_ATTRIBUTES, - 0, - NULL, - CREATE_ALWAYS, - FILE_FLAG_OPEN_REPARSE_POINT | - FILE_FLAG_BACKUP_SEMANTICS, - NULL); - ASSERT_PTR_NE(file_handle, INVALID_HANDLE_VALUE); - - CloseHandle(file_handle); - - r = uv_fs_scandir(NULL, &scandir_req, "test_dir", 0, NULL); - ASSERT_EQ(1, r); - ASSERT_EQ(1, scandir_req.result); - ASSERT_NOT_NULL(scandir_req.ptr); - while (UV_EOF != uv_fs_scandir_next(&scandir_req, &dent)) { - snprintf(test_file_buf, sizeof(test_file_buf), "test_dir\\%s", dent.name); - printf("stat %s\n", test_file_buf); - r = uv_fs_stat(NULL, &stat_req, test_file_buf, NULL); - ASSERT_OK(r); - } - uv_fs_req_cleanup(&scandir_req); - ASSERT_NULL(scandir_req.ptr); - - /* clean-up */ - _wunlink(L"test_dir/hi\xD801\x0037"); - rmdir("test_dir"); - - MAKE_VALGRIND_HAPPY(loop); - return 0; -} -#endif diff --git a/test/test-get-currentexe.c b/test/test-get-currentexe.c index c813d3a..dc239cc 100644 --- a/test/test-get-currentexe.c +++ b/test/test-get-currentexe.c @@ -35,9 +35,6 @@ TEST_IMPL(get_currentexe) { #if defined(__QEMU__) RETURN_SKIP("Test does not currently work in QEMU"); #endif -#if defined(__OpenBSD__) - RETURN_SKIP("Test does not currently work in OpenBSD"); -#endif char buffer[PATHMAX]; char path[PATHMAX]; @@ -60,43 +57,43 @@ TEST_IMPL(get_currentexe) { * executable_path. */ ASSERT(match && !strcmp(match, path)); - ASSERT_EQ(size, strlen(buffer)); + ASSERT(size == strlen(buffer)); /* Negative tests */ size = sizeof(buffer) / sizeof(buffer[0]); r = uv_exepath(NULL, &size); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); r = uv_exepath(buffer, NULL); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); size = 0; r = uv_exepath(buffer, &size); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); memset(buffer, -1, sizeof(buffer)); size = 1; r = uv_exepath(buffer, &size); - ASSERT_OK(r); - ASSERT_OK(size); - ASSERT_EQ(buffer[0], '\0'); + ASSERT(r == 0); + ASSERT(size == 0); + ASSERT(buffer[0] == '\0'); memset(buffer, -1, sizeof(buffer)); size = 2; r = uv_exepath(buffer, &size); - ASSERT_OK(r); - ASSERT_EQ(1, size); - ASSERT_NE(buffer[0], '\0'); - ASSERT_EQ(buffer[1], '\0'); + ASSERT(r == 0); + ASSERT(size == 1); + ASSERT(buffer[0] != '\0'); + ASSERT(buffer[1] == '\0'); /* Verify uv_exepath is not affected by uv_set_process_title(). */ r = uv_set_process_title("foobar"); - ASSERT_OK(r); + ASSERT_EQ(r, 0); size = sizeof(buffer); r = uv_exepath(buffer, &size); - ASSERT_OK(r); + ASSERT_EQ(r, 0); match = strstr(buffer, path); /* Verify that the path returned from uv_exepath is a subdirectory of diff --git a/test/test-get-loadavg.c b/test/test-get-loadavg.c index ef1719c..4762e47 100644 --- a/test/test-get-loadavg.c +++ b/test/test-get-loadavg.c @@ -27,9 +27,9 @@ TEST_IMPL(get_loadavg) { double avg[3] = {-1, -1, -1}; uv_loadavg(avg); - ASSERT_GE(avg[0], 0); - ASSERT_GE(avg[1], 0); - ASSERT_GE(avg[2], 0); + ASSERT(avg[0] >= 0); + ASSERT(avg[1] >= 0); + ASSERT(avg[2] >= 0); return 0; } diff --git a/test/test-get-memory.c b/test/test-get-memory.c index 2a23f79..4555ba0 100644 --- a/test/test-get-memory.c +++ b/test/test-get-memory.c @@ -26,28 +26,19 @@ TEST_IMPL(get_memory) { uint64_t free_mem = uv_get_free_memory(); uint64_t total_mem = uv_get_total_memory(); uint64_t constrained_mem = uv_get_constrained_memory(); - uint64_t available_mem = uv_get_available_memory(); - printf("free_mem=%llu, total_mem=%llu, constrained_mem=%llu, " - "available_mem=%llu\n", + printf("free_mem=%llu, total_mem=%llu, constrained_mem=%llu\n", (unsigned long long) free_mem, (unsigned long long) total_mem, - (unsigned long long) constrained_mem, - (unsigned long long) available_mem); + (unsigned long long) constrained_mem); - ASSERT_GT(free_mem, 0); - ASSERT_GT(total_mem, 0); + ASSERT(free_mem > 0); + ASSERT(total_mem > 0); /* On IBMi PASE, the amount of memory in use is always zero. */ #ifdef __PASE__ - ASSERT_EQ(total_mem, free_mem); + ASSERT(total_mem == free_mem); #else - ASSERT_GT(total_mem, free_mem); + ASSERT(total_mem > free_mem); #endif - ASSERT_LE(available_mem, total_mem); - /* we'd really want to test if available <= free, but that is fragile: - * with no limit set, get_available calls and returns get_free; so if - * any memory was freed between our calls to get_free and get_available - * we would fail such a test test (as observed on CI). - */ return 0; } diff --git a/test/test-get-passwd.c b/test/test-get-passwd.c index b1e7620..352a4b4 100644 --- a/test/test-get-passwd.c +++ b/test/test-get-passwd.c @@ -39,173 +39,17 @@ TEST_IMPL(get_passwd) { /* Test the normal case */ r = uv_os_get_passwd(&pwd); - ASSERT_OK(r); + ASSERT(r == 0); len = strlen(pwd.username); - ASSERT_GT(len, 0); + ASSERT(len > 0); #ifdef _WIN32 ASSERT_NULL(pwd.shell); #else len = strlen(pwd.shell); # ifndef __PASE__ - ASSERT_GT(len, 0); + ASSERT(len > 0); # endif #endif - - len = strlen(pwd.homedir); - ASSERT_GT(len, 0); - -#ifdef _WIN32 - if (len == 3 && pwd.homedir[1] == ':') - ASSERT_EQ(pwd.homedir[2], '\\'); - else - ASSERT_NE(pwd.homedir[len - 1], '\\'); -#else - if (len == 1) - ASSERT_EQ(pwd.homedir[0], '/'); - else - ASSERT_NE(pwd.homedir[len - 1], '/'); -#endif - -#ifdef _WIN32 - ASSERT_EQ(pwd.uid, (unsigned)-1); - ASSERT_EQ(pwd.gid, (unsigned)-1); -#else - ASSERT_NE(pwd.uid, (unsigned)-1); - ASSERT_NE(pwd.gid, (unsigned)-1); - ASSERT_EQ(pwd.uid, geteuid()); - if (pwd.uid != 0 && pwd.gid != getgid()) - /* This will be likely true, as only root could have changed it. */ - ASSERT_EQ(pwd.gid, getegid()); -#endif - - /* Test uv_os_free_passwd() */ - uv_os_free_passwd(&pwd); - - ASSERT_NULL(pwd.username); - ASSERT_NULL(pwd.shell); - ASSERT_NULL(pwd.homedir); - - /* Test a double free */ - uv_os_free_passwd(&pwd); - - ASSERT_NULL(pwd.username); - ASSERT_NULL(pwd.shell); - ASSERT_NULL(pwd.homedir); - - /* Test invalid input */ - r = uv_os_get_passwd(NULL); - ASSERT_EQ(r, UV_EINVAL); - - return 0; -} - - -TEST_IMPL(get_passwd2) { -/* TODO(gengjiawen): Fix test on QEMU. */ -#if defined(__QEMU__) - RETURN_SKIP("Test does not currently work in QEMU"); -#endif - - uv_passwd_t pwd; - uv_passwd_t pwd2; - size_t len; - int r; - - /* Test the normal case */ - r = uv_os_get_passwd(&pwd); - ASSERT_OK(r); - - r = uv_os_get_passwd2(&pwd2, pwd.uid); - -#ifdef _WIN32 - ASSERT_EQ(r, UV_ENOTSUP); - (void) &len; - -#else - ASSERT_OK(r); - ASSERT_EQ(pwd.uid, pwd2.uid); - ASSERT_STR_EQ(pwd.username, pwd2.username); - ASSERT_STR_EQ(pwd.shell, pwd2.shell); - ASSERT_STR_EQ(pwd.homedir, pwd2.homedir); - uv_os_free_passwd(&pwd2); - - r = uv_os_get_passwd2(&pwd2, 0); - ASSERT_OK(r); - - len = strlen(pwd2.username); - ASSERT_GT(len, 0); -#if defined(__PASE__) - // uid 0 is qsecofr on IBM i - ASSERT_STR_EQ(pwd2.username, "qsecofr"); -#else - ASSERT_STR_EQ(pwd2.username, "root"); -#endif - len = strlen(pwd2.homedir); -# ifndef __PASE__ - ASSERT_GT(len, 0); -#endif - len = strlen(pwd2.shell); -# ifndef __PASE__ - ASSERT_GT(len, 0); -# endif - - uv_os_free_passwd(&pwd2); -#endif - - uv_os_free_passwd(&pwd); - - /* Test invalid input */ - r = uv_os_get_passwd2(NULL, pwd.uid); -#ifdef _WIN32 - ASSERT_EQ(r, UV_ENOTSUP); -#else - ASSERT_EQ(r, UV_EINVAL); -#endif - - return 0; -} - - -TEST_IMPL(get_group) { -/* TODO(gengjiawen): Fix test on QEMU. */ -#if defined(__QEMU__) - RETURN_SKIP("Test does not currently work in QEMU"); -#endif - - uv_passwd_t pwd; - uv_group_t grp; - size_t len; - int r; - - r = uv_os_get_passwd(&pwd); - ASSERT_OK(r); - - r = uv_os_get_group(&grp, pwd.gid); - -#ifdef _WIN32 - ASSERT_EQ(r, UV_ENOTSUP); - (void) &len; - -#else - ASSERT_OK(r); - ASSERT_EQ(pwd.gid, grp.gid); - - len = strlen(grp.groupname); - ASSERT_GT(len, 0); - - uv_os_free_group(&grp); -#endif - - uv_os_free_passwd(&pwd); - - /* Test invalid input */ - r = uv_os_get_group(NULL, pwd.gid); -#ifdef _WIN32 - ASSERT_EQ(r, UV_ENOTSUP); -#else - ASSERT_EQ(r, UV_EINVAL); -#endif - return 0; } diff --git a/test/test-getaddrinfo.c b/test/test-getaddrinfo.c index 76137f0..ef1ac02 100644 --- a/test/test-getaddrinfo.c +++ b/test/test-getaddrinfo.c @@ -25,14 +25,6 @@ #define CONCURRENT_COUNT 10 -static const char* name = "localhost"; - -static int getaddrinfo_cbs = 0; - -/* data used for running multiple calls concurrently */ -static uv_getaddrinfo_t* getaddrinfo_handle; -static uv_getaddrinfo_t getaddrinfo_handles[CONCURRENT_COUNT]; -static int callback_counts[CONCURRENT_COUNT]; static int fail_cb_called; @@ -40,73 +32,40 @@ static void getaddrinfo_fail_cb(uv_getaddrinfo_t* req, int status, struct addrinfo* res) { - ASSERT_OK(fail_cb_called); - ASSERT_LT(status, 0); + ASSERT(fail_cb_called == 0); + ASSERT(status < 0); ASSERT_NULL(res); uv_freeaddrinfo(res); /* Should not crash. */ fail_cb_called++; } -static void getaddrinfo_basic_cb(uv_getaddrinfo_t* handle, - int status, - struct addrinfo* res) { - ASSERT_PTR_EQ(handle, getaddrinfo_handle); - getaddrinfo_cbs++; - free(handle); - uv_freeaddrinfo(res); -} - - -static void getaddrinfo_cuncurrent_cb(uv_getaddrinfo_t* handle, - int status, - struct addrinfo* res) { - int i; - int* data = (int*)handle->data; - - for (i = 0; i < CONCURRENT_COUNT; i++) { - if (&getaddrinfo_handles[i] == handle) { - ASSERT_EQ(i, *data); - - callback_counts[i]++; - break; - } - } - ASSERT (i < CONCURRENT_COUNT); - - free(data); - uv_freeaddrinfo(res); - - getaddrinfo_cbs++; -} - - 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(), - &req, - (uv_getaddrinfo_cb) abort, - NULL, - NULL, - NULL)); + ASSERT(UV_EINVAL == uv_getaddrinfo(uv_default_loop(), + &req, + (uv_getaddrinfo_cb) abort, + NULL, + NULL, + NULL)); /* Use a FQDN by ending in a period */ - ASSERT_OK(uv_getaddrinfo(uv_default_loop(), - &req, - getaddrinfo_fail_cb, - "example.invalid.", - NULL, - NULL)); - ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT)); - ASSERT_EQ(1, fail_cb_called); - - MAKE_VALGRIND_HAPPY(uv_default_loop()); + ASSERT(0 == uv_getaddrinfo(uv_default_loop(), + &req, + getaddrinfo_fail_cb, + "example.invalid.", + NULL, + NULL)); + ASSERT(0 == uv_run(uv_default_loop(), UV_RUN_DEFAULT)); + ASSERT(fail_cb_called == 1); + + MAKE_VALGRIND_HAPPY(); return 0; } @@ -119,97 +78,15 @@ TEST_IMPL(getaddrinfo_fail_sync) { uv_getaddrinfo_t req; /* Use a FQDN by ending in a period */ - ASSERT_GT(0, uv_getaddrinfo(uv_default_loop(), - &req, - NULL, - "example.invalid.", - NULL, - NULL)); + ASSERT(0 > uv_getaddrinfo(uv_default_loop(), + &req, + NULL, + "example.invalid.", + NULL, + NULL)); uv_freeaddrinfo(req.addrinfo); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } - -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)); - - r = uv_getaddrinfo(uv_default_loop(), - getaddrinfo_handle, - &getaddrinfo_basic_cb, - name, - NULL, - NULL); - ASSERT_OK(r); - - uv_run(uv_default_loop(), UV_RUN_DEFAULT); - - ASSERT_EQ(1, getaddrinfo_cbs); - - MAKE_VALGRIND_HAPPY(uv_default_loop()); - return 0; -} - - -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(uv_default_loop(), - &req, - NULL, - name, - NULL, - NULL)); - uv_freeaddrinfo(req.addrinfo); - - MAKE_VALGRIND_HAPPY(uv_default_loop()); - return 0; -} - - -TEST_IMPL(getaddrinfo_concurrent) { -/* TODO(gengjiawen): Fix test on QEMU. */ -#if defined(__QEMU__) - RETURN_SKIP("Test does not currently work in QEMU"); -#endif - - int i, r; - int* data; - - for (i = 0; i < CONCURRENT_COUNT; i++) { - callback_counts[i] = 0; - - data = (int*)malloc(sizeof(int)); - ASSERT_NOT_NULL(data); - *data = i; - getaddrinfo_handles[i].data = data; - - r = uv_getaddrinfo(uv_default_loop(), - &getaddrinfo_handles[i], - &getaddrinfo_cuncurrent_cb, - name, - NULL, - NULL); - ASSERT_OK(r); - } - - uv_run(uv_default_loop(), UV_RUN_DEFAULT); - - for (i = 0; i < CONCURRENT_COUNT; i++) { - ASSERT_EQ(1, callback_counts[i]); - } - - MAKE_VALGRIND_HAPPY(uv_default_loop()); - return 0; -} diff --git a/test/test-gethostname.c b/test/test-gethostname.c index cc15a82..1a9816d 100644 --- a/test/test-gethostname.c +++ b/test/test-gethostname.c @@ -32,27 +32,27 @@ TEST_IMPL(gethostname) { /* Reject invalid inputs */ size = 1; r = uv_os_gethostname(NULL, &size); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); r = uv_os_gethostname(buf, NULL); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); size = 0; r = uv_os_gethostname(buf, &size); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); /* Return UV_ENOBUFS if the buffer cannot hold the hostname */ enobufs_size = 1; buf[0] = '\0'; r = uv_os_gethostname(buf, &enobufs_size); - ASSERT_EQ(r, UV_ENOBUFS); - ASSERT_EQ(buf[0], '\0'); - ASSERT_GT(enobufs_size, 1); + ASSERT(r == UV_ENOBUFS); + ASSERT(buf[0] == '\0'); + ASSERT(enobufs_size > 1); /* Successfully get the hostname */ size = UV_MAXHOSTNAMESIZE; r = uv_os_gethostname(buf, &size); - ASSERT_OK(r); + ASSERT(r == 0); ASSERT(size > 0 && size == strlen(buf)); - ASSERT_EQ(size + 1, enobufs_size); + ASSERT(size + 1 == enobufs_size); return 0; } diff --git a/test/test-getnameinfo.c b/test/test-getnameinfo.c index 415e48a..a2f78ea 100644 --- a/test/test-getnameinfo.c +++ b/test/test-getnameinfo.c @@ -39,78 +39,7 @@ static void getnameinfo_req(uv_getnameinfo_t* handle, const char* hostname, const char* service) { ASSERT_NOT_NULL(handle); - ASSERT_OK(status); + ASSERT(status == 0); ASSERT_NOT_NULL(hostname); ASSERT_NOT_NULL(service); } - - -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); - ASSERT_OK(r); - - r = uv_getnameinfo(uv_default_loop(), - &req, - &getnameinfo_req, - (const struct sockaddr*)&addr4, - 0); - ASSERT_OK(r); - - uv_run(uv_default_loop(), UV_RUN_DEFAULT); - - MAKE_VALGRIND_HAPPY(uv_default_loop()); - return 0; -} - - -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(), - &req, - NULL, - (const struct sockaddr*)&addr4, - 0)); - ASSERT_NE(req.host[0], '\0'); - ASSERT_NE(req.service[0], '\0'); - - MAKE_VALGRIND_HAPPY(uv_default_loop()); - return 0; -} - - -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); - ASSERT_OK(r); - - r = uv_getnameinfo(uv_default_loop(), - &req, - &getnameinfo_req, - (const struct sockaddr*)&addr6, - 0); - ASSERT_OK(r); - - uv_run(uv_default_loop(), UV_RUN_DEFAULT); - - MAKE_VALGRIND_HAPPY(uv_default_loop()); - return 0; -} diff --git a/test/test-getsockname.c b/test/test-getsockname.c index 7bc0ba2..6e0f8c1 100644 --- a/test/test-getsockname.c +++ b/test/test-getsockname.c @@ -73,7 +73,7 @@ static void after_read(uv_stream_t* handle, req = (uv_shutdown_t*) malloc(sizeof *req); r = uv_shutdown(req, handle, after_shutdown); - ASSERT_OK(r); + ASSERT(r == 0); } @@ -84,22 +84,22 @@ static void check_sockname(struct sockaddr* addr, const char* compare_ip, char check_ip[17]; int r; - ASSERT_OK(uv_ip4_addr(compare_ip, compare_port, &compare_addr)); + ASSERT(0 == uv_ip4_addr(compare_ip, compare_port, &compare_addr)); /* Both addresses should be ipv4 */ - ASSERT_EQ(check_addr.sin_family, AF_INET); - ASSERT_EQ(compare_addr.sin_family, AF_INET); + ASSERT(check_addr.sin_family == AF_INET); + ASSERT(compare_addr.sin_family == AF_INET); /* Check if the ip matches */ - ASSERT_OK(memcmp(&check_addr.sin_addr, - &compare_addr.sin_addr, - sizeof compare_addr.sin_addr)); + ASSERT(memcmp(&check_addr.sin_addr, + &compare_addr.sin_addr, + sizeof compare_addr.sin_addr) == 0); /* Check if the port matches. If port == 0 anything goes. */ ASSERT(compare_port == 0 || check_addr.sin_port == compare_addr.sin_port); r = uv_ip4_name(&check_addr, (char*) check_ip, sizeof check_ip); - ASSERT_OK(r); + ASSERT(r == 0); printf("%s: %s:%d\n", context, check_ip, ntohs(check_addr.sin_port)); } @@ -114,34 +114,34 @@ static void on_connection(uv_stream_t* server, int status) { if (status != 0) { fprintf(stderr, "Connect error %s\n", uv_err_name(status)); } - ASSERT_OK(status); + ASSERT(status == 0); handle = malloc(sizeof(*handle)); ASSERT_NOT_NULL(handle); r = uv_tcp_init(loop, handle); - ASSERT_OK(r); + ASSERT(r == 0); /* associate server with stream */ handle->data = server; r = uv_accept(server, (uv_stream_t*)handle); - ASSERT_OK(r); + ASSERT(r == 0); namelen = sizeof sockname; r = uv_tcp_getsockname(handle, &sockname, &namelen); - ASSERT_OK(r); + ASSERT(r == 0); check_sockname(&sockname, "127.0.0.1", server_port, "accepted socket"); getsocknamecount_tcp++; namelen = sizeof peername; r = uv_tcp_getpeername(handle, &peername, &namelen); - ASSERT_OK(r); + ASSERT(r == 0); check_sockname(&peername, "127.0.0.1", connect_port, "accepted socket peer"); getpeernamecount++; r = uv_read_start((uv_stream_t*)handle, alloc, after_read); - ASSERT_OK(r); + ASSERT(r == 0); } @@ -149,17 +149,17 @@ static void on_connect(uv_connect_t* req, int status) { struct sockaddr sockname, peername; int r, namelen; - ASSERT_OK(status); + ASSERT(status == 0); namelen = sizeof sockname; r = uv_tcp_getsockname((uv_tcp_t*) req->handle, &sockname, &namelen); - ASSERT_OK(r); + ASSERT(r == 0); check_sockname(&sockname, "127.0.0.1", 0, "connected socket"); getsocknamecount_tcp++; namelen = sizeof peername; r = uv_tcp_getpeername((uv_tcp_t*) req->handle, &peername, &namelen); - ASSERT_OK(r); + ASSERT(r == 0); check_sockname(&peername, "127.0.0.1", server_port, "connected socket peer"); getpeernamecount++; @@ -173,7 +173,7 @@ static int tcp_listener(void) { int namelen; int r; - ASSERT_OK(uv_ip4_addr("0.0.0.0", server_port, &addr)); + ASSERT(0 == uv_ip4_addr("0.0.0.0", server_port, &addr)); r = uv_tcp_init(loop, &tcpServer); if (r) { @@ -196,13 +196,13 @@ static int tcp_listener(void) { memset(&sockname, -1, sizeof sockname); namelen = sizeof sockname; r = uv_tcp_getsockname(&tcpServer, &sockname, &namelen); - ASSERT_OK(r); + ASSERT(r == 0); check_sockname(&sockname, "0.0.0.0", server_port, "server socket"); getsocknamecount_tcp++; namelen = sizeof sockname; r = uv_tcp_getpeername(&tcpServer, &peername, &namelen); - ASSERT_EQ(r, UV_ENOTCONN); + ASSERT(r == UV_ENOTCONN); getpeernamecount++; return 0; @@ -214,7 +214,7 @@ static void tcp_connector(void) { struct sockaddr sockname; int r, namelen; - ASSERT_OK(uv_ip4_addr("127.0.0.1", server_port, &server_addr)); + ASSERT(0 == uv_ip4_addr("127.0.0.1", server_port, &server_addr)); r = uv_tcp_init(loop, &tcp); tcp.data = &connect_req; @@ -230,9 +230,9 @@ static void tcp_connector(void) { namelen = sizeof sockname; r = uv_tcp_getsockname(&tcp, &sockname, &namelen); ASSERT(!r); - ASSERT_EQ(sockname.sa_family, AF_INET); + ASSERT(sockname.sa_family == AF_INET); connect_port = ntohs(((struct sockaddr_in*) &sockname)->sin_port); - ASSERT_GT(connect_port, 0); + ASSERT(connect_port > 0); } @@ -245,7 +245,7 @@ static void udp_recv(uv_udp_t* handle, int namelen; int r; - ASSERT_GE(nread, 0); + ASSERT(nread >= 0); free(buf->base); if (nread == 0) { @@ -255,7 +255,7 @@ static void udp_recv(uv_udp_t* handle, memset(&sockname, -1, sizeof sockname); namelen = sizeof(sockname); r = uv_udp_getsockname(&udp, &sockname, &namelen); - ASSERT_OK(r); + ASSERT(r == 0); check_sockname(&sockname, "0.0.0.0", 0, "udp receiving socket"); getsocknamecount_udp++; @@ -275,7 +275,7 @@ static int udp_listener(void) { int namelen; int r; - ASSERT_OK(uv_ip4_addr("0.0.0.0", server_port, &addr)); + ASSERT(0 == uv_ip4_addr("0.0.0.0", server_port, &addr)); r = uv_udp_init(loop, &udpServer); if (r) { @@ -292,12 +292,12 @@ static int udp_listener(void) { memset(&sockname, -1, sizeof sockname); namelen = sizeof sockname; r = uv_udp_getsockname(&udpServer, &sockname, &namelen); - ASSERT_OK(r); + ASSERT(r == 0); check_sockname(&sockname, "0.0.0.0", server_port, "udp listener socket"); getsocknamecount_udp++; r = uv_udp_recv_start(&udpServer, alloc, udp_recv); - ASSERT_OK(r); + ASSERT(r == 0); return 0; } @@ -312,7 +312,7 @@ static void udp_sender(void) { ASSERT(!r); buf = uv_buf_init("PING", 4); - ASSERT_OK(uv_ip4_addr("127.0.0.1", server_port, &server_addr)); + ASSERT(0 == uv_ip4_addr("127.0.0.1", server_port, &server_addr)); r = uv_udp_send(&send_req, &udp, @@ -334,10 +334,10 @@ TEST_IMPL(getsockname_tcp) { uv_run(loop, UV_RUN_DEFAULT); - ASSERT_EQ(3, getsocknamecount_tcp); - ASSERT_EQ(3, getpeernamecount); + ASSERT(getsocknamecount_tcp == 3); + ASSERT(getpeernamecount == 3); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -352,11 +352,11 @@ TEST_IMPL(getsockname_udp) { uv_run(loop, UV_RUN_DEFAULT); - ASSERT_EQ(2, getsocknamecount_udp); + ASSERT(getsocknamecount_udp == 2); - ASSERT_OK(udp.send_queue_size); - ASSERT_OK(udpServer.send_queue_size); + ASSERT(udp.send_queue_size == 0); + ASSERT(udpServer.send_queue_size == 0); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-getters-setters.c b/test/test-getters-setters.c index 3b9e89e..2a37122 100644 --- a/test/test-getters-setters.c +++ b/test/test-getters-setters.c @@ -24,19 +24,15 @@ #include #include -#ifdef _WIN32 -# define S_IFDIR _S_IFDIR -#endif - int cookie1; int cookie2; int cookie3; TEST_IMPL(handle_type_name) { - ASSERT_OK(strcmp(uv_handle_type_name(UV_NAMED_PIPE), "pipe")); - ASSERT_OK(strcmp(uv_handle_type_name(UV_UDP), "udp")); - ASSERT_OK(strcmp(uv_handle_type_name(UV_FILE), "file")); + ASSERT(strcmp(uv_handle_type_name(UV_NAMED_PIPE), "pipe") == 0); + ASSERT(strcmp(uv_handle_type_name(UV_UDP), "udp") == 0); + ASSERT(strcmp(uv_handle_type_name(UV_FILE), "file") == 0); ASSERT_NULL(uv_handle_type_name(UV_HANDLE_TYPE_MAX)); ASSERT_NULL(uv_handle_type_name(UV_HANDLE_TYPE_MAX + 1)); ASSERT_NULL(uv_handle_type_name(UV_UNKNOWN_HANDLE)); @@ -45,9 +41,9 @@ TEST_IMPL(handle_type_name) { TEST_IMPL(req_type_name) { - ASSERT_OK(strcmp(uv_req_type_name(UV_REQ), "req")); - ASSERT_OK(strcmp(uv_req_type_name(UV_UDP_SEND), "udp_send")); - ASSERT_OK(strcmp(uv_req_type_name(UV_WORK), "work")); + ASSERT(strcmp(uv_req_type_name(UV_REQ), "req") == 0); + ASSERT(strcmp(uv_req_type_name(UV_UDP_SEND), "udp_send") == 0); + ASSERT(strcmp(uv_req_type_name(UV_WORK), "work") == 0); ASSERT_NULL(uv_req_type_name(UV_REQ_TYPE_MAX)); ASSERT_NULL(uv_req_type_name(UV_REQ_TYPE_MAX + 1)); ASSERT_NULL(uv_req_type_name(UV_UNKNOWN_REQ)); @@ -64,48 +60,47 @@ TEST_IMPL(getters_setters) { loop = malloc(uv_loop_size()); ASSERT_NOT_NULL(loop); r = uv_loop_init(loop); - ASSERT_OK(r); + ASSERT(r == 0); uv_loop_set_data(loop, &cookie1); - ASSERT_PTR_EQ(loop->data, &cookie1); - ASSERT_PTR_EQ(uv_loop_get_data(loop), &cookie1); + ASSERT(loop->data == &cookie1); + ASSERT(uv_loop_get_data(loop) == &cookie1); pipe = malloc(uv_handle_size(UV_NAMED_PIPE)); r = uv_pipe_init(loop, pipe, 0); - ASSERT_OK(r); - ASSERT_EQ(uv_handle_get_type((uv_handle_t*)pipe), UV_NAMED_PIPE); + ASSERT(uv_handle_get_type((uv_handle_t*)pipe) == UV_NAMED_PIPE); - ASSERT_PTR_EQ(uv_handle_get_loop((uv_handle_t*)pipe), loop); + ASSERT(uv_handle_get_loop((uv_handle_t*)pipe) == loop); pipe->data = &cookie2; - ASSERT_PTR_EQ(uv_handle_get_data((uv_handle_t*)pipe), &cookie2); + ASSERT(uv_handle_get_data((uv_handle_t*)pipe) == &cookie2); uv_handle_set_data((uv_handle_t*)pipe, &cookie1); - ASSERT_PTR_EQ(uv_handle_get_data((uv_handle_t*)pipe), &cookie1); - ASSERT_PTR_EQ(pipe->data, &cookie1); + ASSERT(uv_handle_get_data((uv_handle_t*)pipe) == &cookie1); + ASSERT(pipe->data == &cookie1); - ASSERT_OK(uv_stream_get_write_queue_size((uv_stream_t*)pipe)); + ASSERT(uv_stream_get_write_queue_size((uv_stream_t*)pipe) == 0); pipe->write_queue_size++; - ASSERT_EQ(1, uv_stream_get_write_queue_size((uv_stream_t*)pipe)); + ASSERT(uv_stream_get_write_queue_size((uv_stream_t*)pipe) == 1); pipe->write_queue_size--; uv_close((uv_handle_t*)pipe, NULL); r = uv_run(loop, UV_RUN_DEFAULT); - ASSERT_OK(r); + ASSERT(r == 0); fs = malloc(uv_req_size(UV_FS)); uv_fs_stat(loop, fs, ".", NULL); r = uv_run(loop, UV_RUN_DEFAULT); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_EQ(uv_fs_get_type(fs), UV_FS_STAT); - ASSERT_OK(uv_fs_get_result(fs)); - ASSERT_PTR_EQ(uv_fs_get_ptr(fs), uv_fs_get_statbuf(fs)); + ASSERT(uv_fs_get_type(fs) == UV_FS_STAT); + ASSERT(uv_fs_get_result(fs) == 0); + ASSERT(uv_fs_get_ptr(fs) == uv_fs_get_statbuf(fs)); ASSERT(uv_fs_get_statbuf(fs)->st_mode & S_IFDIR); - ASSERT_OK(strcmp(uv_fs_get_path(fs), ".")); + ASSERT(strcmp(uv_fs_get_path(fs), ".") == 0); uv_fs_req_cleanup(fs); r = uv_loop_close(loop); - ASSERT_OK(r); + ASSERT(r == 0); free(pipe); free(fs); diff --git a/test/test-gettimeofday.c b/test/test-gettimeofday.c index 7d90128..4ebc11f 100644 --- a/test/test-gettimeofday.c +++ b/test/test-gettimeofday.c @@ -28,12 +28,12 @@ TEST_IMPL(gettimeofday) { tv.tv_sec = 0; r = uv_gettimeofday(&tv); - ASSERT_OK(r); - ASSERT_NE(0, tv.tv_sec); + ASSERT(r == 0); + ASSERT(tv.tv_sec != 0); /* Test invalid input. */ r = uv_gettimeofday(NULL); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); return 0; } diff --git a/test/test-handle-fileno.c b/test/test-handle-fileno.c index be53152..8a093e2 100644 --- a/test/test-handle-fileno.c +++ b/test/test-handle-fileno.c @@ -56,49 +56,49 @@ TEST_IMPL(handle_fileno) { uv_loop_t* loop; loop = uv_default_loop(); - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); + ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); r = uv_idle_init(loop, &idle); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_fileno((uv_handle_t*) &idle, &fd); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); uv_close((uv_handle_t*) &idle, NULL); r = uv_tcp_init(loop, &tcp); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_fileno((uv_handle_t*) &tcp, &fd); - ASSERT_EQ(r, UV_EBADF); + ASSERT(r == UV_EBADF); r = uv_tcp_bind(&tcp, (const struct sockaddr*) &addr, 0); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_fileno((uv_handle_t*) &tcp, &fd); - ASSERT_OK(r); + ASSERT(r == 0); uv_close((uv_handle_t*) &tcp, NULL); r = uv_fileno((uv_handle_t*) &tcp, &fd); - ASSERT_EQ(r, UV_EBADF); + ASSERT(r == UV_EBADF); r = uv_udp_init(loop, &udp); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_fileno((uv_handle_t*) &udp, &fd); - ASSERT_EQ(r, UV_EBADF); + ASSERT(r == UV_EBADF); r = uv_udp_bind(&udp, (const struct sockaddr*) &addr, 0); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_fileno((uv_handle_t*) &udp, &fd); - ASSERT_OK(r); + ASSERT(r == 0); uv_close((uv_handle_t*) &udp, NULL); r = uv_fileno((uv_handle_t*) &udp, &fd); - ASSERT_EQ(r, UV_EBADF); + ASSERT(r == UV_EBADF); r = uv_pipe_init(loop, &pipe, 0); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_fileno((uv_handle_t*) &pipe, &fd); - ASSERT_EQ(r, UV_EBADF); + ASSERT(r == UV_EBADF); r = uv_pipe_bind(&pipe, TEST_PIPENAME); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_fileno((uv_handle_t*) &pipe, &fd); - ASSERT_OK(r); + ASSERT(r == 0); uv_close((uv_handle_t*) &pipe, NULL); r = uv_fileno((uv_handle_t*) &pipe, &fd); - ASSERT_EQ(r, UV_EBADF); + ASSERT(r == UV_EBADF); tty_fd = get_tty_fd(); if (tty_fd < 0) { @@ -106,20 +106,20 @@ TEST_IMPL(handle_fileno) { fflush(stderr); } else { r = uv_tty_init(loop, &tty, tty_fd, 0); - ASSERT_OK(r); + ASSERT(r == 0); ASSERT(uv_is_readable((uv_stream_t*) &tty)); ASSERT(!uv_is_writable((uv_stream_t*) &tty)); r = uv_fileno((uv_handle_t*) &tty, &fd); - ASSERT_OK(r); + ASSERT(r == 0); uv_close((uv_handle_t*) &tty, NULL); r = uv_fileno((uv_handle_t*) &tty, &fd); - ASSERT_EQ(r, UV_EBADF); + ASSERT(r == UV_EBADF); ASSERT(!uv_is_readable((uv_stream_t*) &tty)); ASSERT(!uv_is_writable((uv_stream_t*) &tty)); } uv_run(loop, UV_RUN_DEFAULT); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-homedir.c b/test/test-homedir.c index 769d5c8..508351f 100644 --- a/test/test-homedir.c +++ b/test/test-homedir.c @@ -34,39 +34,39 @@ TEST_IMPL(homedir) { /* Test the normal case */ len = sizeof homedir; homedir[0] = '\0'; - ASSERT_OK(strlen(homedir)); + ASSERT(strlen(homedir) == 0); r = uv_os_homedir(homedir, &len); - ASSERT_OK(r); - ASSERT_EQ(strlen(homedir), len); - ASSERT_GT(len, 0); - ASSERT_EQ(homedir[len], '\0'); + ASSERT(r == 0); + ASSERT(strlen(homedir) == len); + ASSERT(len > 0); + ASSERT(homedir[len] == '\0'); #ifdef _WIN32 if (len == 3 && homedir[1] == ':') - ASSERT_EQ(homedir[2], '\\'); + ASSERT(homedir[2] == '\\'); else - ASSERT_NE(homedir[len - 1], '\\'); + ASSERT(homedir[len - 1] != '\\'); #else if (len == 1) - ASSERT_EQ(homedir[0], '/'); + ASSERT(homedir[0] == '/'); else - ASSERT_NE(homedir[len - 1], '/'); + ASSERT(homedir[len - 1] != '/'); #endif /* Test the case where the buffer is too small */ len = SMALLPATH; r = uv_os_homedir(homedir, &len); - ASSERT_EQ(r, UV_ENOBUFS); - ASSERT_GT(len, SMALLPATH); + ASSERT(r == UV_ENOBUFS); + ASSERT(len > SMALLPATH); /* Test invalid inputs */ r = uv_os_homedir(NULL, &len); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); r = uv_os_homedir(homedir, NULL); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); len = 0; r = uv_os_homedir(homedir, &len); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); return 0; } diff --git a/test/test-hrtime.c b/test/test-hrtime.c index c0b88c6..9d461d9 100644 --- a/test/test-hrtime.c +++ b/test/test-hrtime.c @@ -45,21 +45,8 @@ TEST_IMPL(hrtime) { * that the difference between the two hrtime values has a reasonable * lower bound. */ - ASSERT_UINT64_GT(diff, (uint64_t) 25 * NANOSEC / MILLISEC); + ASSERT(diff > (uint64_t) 25 * NANOSEC / MILLISEC); --i; } return 0; } - - -TEST_IMPL(clock_gettime) { - uv_timespec64_t t; - - ASSERT_EQ(UV_EINVAL, uv_clock_gettime(1337, &t)); - ASSERT_EQ(UV_EFAULT, uv_clock_gettime(1337, NULL)); - ASSERT_OK(uv_clock_gettime(UV_CLOCK_MONOTONIC, &t)); - ASSERT_OK(uv_clock_gettime(UV_CLOCK_REALTIME, &t)); - ASSERT_GT(1682500000000ll, t.tv_sec); /* 2023-04-26T09:06:40.000Z */ - - return 0; -} diff --git a/test/test-idle.c b/test/test-idle.c index 069e348..427cf54 100644 --- a/test/test-idle.c +++ b/test/test-idle.c @@ -39,7 +39,7 @@ static void close_cb(uv_handle_t* handle) { static void timer_cb(uv_timer_t* handle) { - ASSERT_PTR_EQ(handle, &timer_handle); + ASSERT(handle == &timer_handle); uv_close((uv_handle_t*) &idle_handle, close_cb); uv_close((uv_handle_t*) &check_handle, close_cb); @@ -52,7 +52,7 @@ static void timer_cb(uv_timer_t* handle) { static void idle_cb(uv_idle_t* handle) { - ASSERT_PTR_EQ(handle, &idle_handle); + ASSERT(handle == &idle_handle); idle_cb_called++; fprintf(stderr, "idle_cb %d\n", idle_cb_called); @@ -61,7 +61,7 @@ static void idle_cb(uv_idle_t* handle) { static void check_cb(uv_check_t* handle) { - ASSERT_PTR_EQ(handle, &check_handle); + ASSERT(handle == &check_handle); check_cb_called++; fprintf(stderr, "check_cb %d\n", check_cb_called); @@ -73,28 +73,28 @@ TEST_IMPL(idle_starvation) { int r; r = uv_idle_init(uv_default_loop(), &idle_handle); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_idle_start(&idle_handle, idle_cb); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_check_init(uv_default_loop(), &check_handle); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_check_start(&check_handle, check_cb); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_timer_init(uv_default_loop(), &timer_handle); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_timer_start(&timer_handle, timer_cb, 50, 0); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_GT(idle_cb_called, 0); - ASSERT_EQ(1, timer_cb_called); - ASSERT_EQ(3, close_cb_called); + ASSERT(idle_cb_called > 0); + ASSERT(timer_cb_called == 1); + ASSERT(close_cb_called == 3); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -105,21 +105,21 @@ static void idle_stop(uv_idle_t* handle) { TEST_IMPL(idle_check) { - ASSERT_OK(uv_idle_init(uv_default_loop(), &idle_handle)); - ASSERT_OK(uv_idle_start(&idle_handle, idle_stop)); + ASSERT_EQ(0, uv_idle_init(uv_default_loop(), &idle_handle)); + ASSERT_EQ(0, uv_idle_start(&idle_handle, idle_stop)); - ASSERT_OK(uv_check_init(uv_default_loop(), &check_handle)); - ASSERT_OK(uv_check_start(&check_handle, check_cb)); + ASSERT_EQ(0, uv_check_init(uv_default_loop(), &check_handle)); + ASSERT_EQ(0, uv_check_start(&check_handle, check_cb)); ASSERT_EQ(1, uv_run(uv_default_loop(), UV_RUN_ONCE)); ASSERT_EQ(1, check_cb_called); - ASSERT_OK(close_cb_called); + ASSERT_EQ(0, close_cb_called); uv_close((uv_handle_t*) &idle_handle, close_cb); uv_close((uv_handle_t*) &check_handle, close_cb); - ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_ONCE)); + ASSERT_EQ(0, uv_run(uv_default_loop(), UV_RUN_ONCE)); ASSERT_EQ(2, close_cb_called); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-idna.c b/test/test-idna.c index 28f9eaa..180a6a6 100644 --- a/test/test-idna.c +++ b/test/test-idna.c @@ -20,8 +20,7 @@ */ #include "task.h" -#define uv__malloc malloc -#include "../src/idna.c" +#include "../src/idna.h" #include TEST_IMPL(utf8_decode1) { @@ -32,66 +31,66 @@ TEST_IMPL(utf8_decode1) { /* ASCII. */ p = b; snprintf(b, sizeof(b), "%c\x7F", 0x00); - ASSERT_OK(uv__utf8_decode1(&p, b + sizeof(b))); - ASSERT_PTR_EQ(p, b + 1); - ASSERT_EQ(127, uv__utf8_decode1(&p, b + sizeof(b))); - ASSERT_PTR_EQ(p, b + 2); + ASSERT(0 == uv__utf8_decode1(&p, b + sizeof(b))); + ASSERT(p == b + 1); + ASSERT(127 == uv__utf8_decode1(&p, b + sizeof(b))); + ASSERT(p == b + 2); /* Two-byte sequences. */ p = b; snprintf(b, sizeof(b), "\xC2\x80\xDF\xBF"); - ASSERT_EQ(128, uv__utf8_decode1(&p, b + sizeof(b))); - ASSERT_PTR_EQ(p, b + 2); - ASSERT_EQ(0x7FF, uv__utf8_decode1(&p, b + sizeof(b))); - ASSERT_PTR_EQ(p, b + 4); + ASSERT(128 == uv__utf8_decode1(&p, b + sizeof(b))); + ASSERT(p == b + 2); + ASSERT(0x7FF == uv__utf8_decode1(&p, b + sizeof(b))); + ASSERT(p == b + 4); /* Three-byte sequences. */ p = b; snprintf(b, sizeof(b), "\xE0\xA0\x80\xEF\xBF\xBF"); - ASSERT_EQ(0x800, uv__utf8_decode1(&p, b + sizeof(b))); - ASSERT_PTR_EQ(p, b + 3); - ASSERT_EQ(0xFFFF, uv__utf8_decode1(&p, b + sizeof(b))); - ASSERT_PTR_EQ(p, b + 6); + ASSERT(0x800 == uv__utf8_decode1(&p, b + sizeof(b))); + ASSERT(p == b + 3); + ASSERT(0xFFFF == uv__utf8_decode1(&p, b + sizeof(b))); + ASSERT(p == b + 6); /* Four-byte sequences. */ p = b; snprintf(b, sizeof(b), "\xF0\x90\x80\x80\xF4\x8F\xBF\xBF"); - ASSERT_EQ(0x10000, uv__utf8_decode1(&p, b + sizeof(b))); - ASSERT_PTR_EQ(p, b + 4); - ASSERT_EQ(0x10FFFF, uv__utf8_decode1(&p, b + sizeof(b))); - ASSERT_PTR_EQ(p, b + 8); + ASSERT(0x10000 == uv__utf8_decode1(&p, b + sizeof(b))); + ASSERT(p == b + 4); + ASSERT(0x10FFFF == uv__utf8_decode1(&p, b + sizeof(b))); + ASSERT(p == b + 8); /* Four-byte sequences > U+10FFFF; disallowed. */ p = b; snprintf(b, sizeof(b), "\xF4\x90\xC0\xC0\xF7\xBF\xBF\xBF"); - ASSERT_EQ((unsigned) -1, uv__utf8_decode1(&p, b + sizeof(b))); - ASSERT_PTR_EQ(p, b + 4); - ASSERT_EQ((unsigned) -1, uv__utf8_decode1(&p, b + sizeof(b))); - ASSERT_PTR_EQ(p, b + 8); + ASSERT((unsigned) -1 == uv__utf8_decode1(&p, b + sizeof(b))); + ASSERT(p == b + 4); + ASSERT((unsigned) -1 == uv__utf8_decode1(&p, b + sizeof(b))); + ASSERT(p == b + 8); /* Overlong; disallowed. */ p = b; snprintf(b, sizeof(b), "\xC0\x80\xC1\x80"); - ASSERT_EQ((unsigned) -1, uv__utf8_decode1(&p, b + sizeof(b))); - ASSERT_PTR_EQ(p, b + 2); - ASSERT_EQ((unsigned) -1, uv__utf8_decode1(&p, b + sizeof(b))); - ASSERT_PTR_EQ(p, b + 4); + ASSERT((unsigned) -1 == uv__utf8_decode1(&p, b + sizeof(b))); + ASSERT(p == b + 2); + ASSERT((unsigned) -1 == uv__utf8_decode1(&p, b + sizeof(b))); + ASSERT(p == b + 4); /* Surrogate pairs; disallowed. */ p = b; snprintf(b, sizeof(b), "\xED\xA0\x80\xED\xA3\xBF"); - ASSERT_EQ((unsigned) -1, uv__utf8_decode1(&p, b + sizeof(b))); - ASSERT_PTR_EQ(p, b + 3); - ASSERT_EQ((unsigned) -1, uv__utf8_decode1(&p, b + sizeof(b))); - ASSERT_PTR_EQ(p, b + 6); + ASSERT((unsigned) -1 == uv__utf8_decode1(&p, b + sizeof(b))); + ASSERT(p == b + 3); + ASSERT((unsigned) -1 == uv__utf8_decode1(&p, b + sizeof(b))); + ASSERT(p == b + 6); /* Simply illegal. */ p = b; snprintf(b, sizeof(b), "\xF8\xF9\xFA\xFB\xFC\xFD\xFE\xFF"); for (i = 1; i <= 8; i++) { - ASSERT_EQ((unsigned) -1, uv__utf8_decode1(&p, b + sizeof(b))); - ASSERT_PTR_EQ(p, b + i); + ASSERT((unsigned) -1 == uv__utf8_decode1(&p, b + sizeof(b))); + ASSERT(p == b + i); } return 0; @@ -101,17 +100,16 @@ TEST_IMPL(utf8_decode1_overrun) { const char* p; char b[1]; char c[1]; - /* Single byte. */ p = b; b[0] = 0x7F; - ASSERT_EQ(0x7F, uv__utf8_decode1(&p, b + 1)); - ASSERT_PTR_EQ(p, b + 1); + ASSERT((unsigned int)0x7F == uv__utf8_decode1(&p, b + 1)); + ASSERT_EQ(p, b + 1); /* Multi-byte. */ p = b; b[0] = 0xC0; - ASSERT_EQ((unsigned) -1, uv__utf8_decode1(&p, b + 1)); + ASSERT_EQ((unsigned int) -1, uv__utf8_decode1(&p, b + 1)); ASSERT_PTR_EQ(p, b + 1); b[0] = 0x7F; @@ -128,7 +126,7 @@ TEST_IMPL(utf8_decode1_overrun) { do { \ char d[256] = {0}; \ static const char s[] = "" input ""; \ - ASSERT_EQ(err, uv__idna_toascii(s, s + sizeof(s) - 1, d, d + sizeof(d))); \ + ASSERT(err == uv__idna_toascii(s, s + sizeof(s) - 1, d, d + sizeof(d))); \ } while (0) #define T(input, expected) \ @@ -138,13 +136,13 @@ TEST_IMPL(utf8_decode1_overrun) { char d2[256] = {0}; \ static const char s[] = "" input ""; \ n = uv__idna_toascii(s, s + sizeof(s) - 1, d1, d1 + sizeof(d1)); \ - ASSERT_EQ(n, sizeof(expected)); \ - ASSERT_OK(memcmp(d1, expected, n)); \ + ASSERT(n == sizeof(expected)); \ + ASSERT(0 == memcmp(d1, expected, n)); \ /* Sanity check: encoding twice should not change the output. */ \ n = uv__idna_toascii(d1, d1 + strlen(d1), d2, d2 + sizeof(d2)); \ - ASSERT_EQ(n, sizeof(expected)); \ - ASSERT_OK(memcmp(d2, expected, n)); \ - ASSERT_OK(memcmp(d1, d2, sizeof(d2))); \ + ASSERT(n == sizeof(expected)); \ + ASSERT(0 == memcmp(d2, expected, n)); \ + ASSERT(0 == memcmp(d1, d2, sizeof(d2))); \ } while (0) TEST_IMPL(idna_toascii) { diff --git a/test/test-ip-name.c b/test/test-ip-name.c index cdc0c56..1cb1b60 100644 --- a/test/test-ip-name.c +++ b/test/test-ip-name.c @@ -40,26 +40,26 @@ TEST_IMPL(ip_name) { struct sockaddr_in6* addr6 = &test_addr.addr6; /* test ip4_name */ - ASSERT_OK(uv_ip4_addr("192.168.0.1", TEST_PORT, addr4)); - ASSERT_OK(uv_ip4_name(addr4, dst, INET_ADDRSTRLEN)); - ASSERT_OK(strcmp("192.168.0.1", dst)); + ASSERT_EQ(0, uv_ip4_addr("192.168.0.1", TEST_PORT, addr4)); + ASSERT_EQ(0, uv_ip4_name(addr4, dst, INET_ADDRSTRLEN)); + ASSERT_EQ(0, strcmp("192.168.0.1", dst)); - ASSERT_OK(uv_ip_name(addr, dst, INET_ADDRSTRLEN)); - ASSERT_OK(strcmp("192.168.0.1", dst)); + ASSERT_EQ(0, uv_ip_name(addr, dst, INET_ADDRSTRLEN)); + ASSERT_EQ(0, strcmp("192.168.0.1", dst)); /* test ip6_name */ - ASSERT_OK(uv_ip6_addr("fe80::2acf:daff:fedd:342a", TEST_PORT, addr6)); - ASSERT_OK(uv_ip6_name(addr6, dst, INET6_ADDRSTRLEN)); - ASSERT_OK(strcmp("fe80::2acf:daff:fedd:342a", dst)); - - ASSERT_OK(uv_ip_name(addr, dst, INET6_ADDRSTRLEN)); - ASSERT_OK(strcmp("fe80::2acf:daff:fedd:342a", dst)); + ASSERT_EQ(0, uv_ip6_addr("fe80::2acf:daff:fedd:342a", TEST_PORT, addr6)); + ASSERT_EQ(0, uv_ip6_name(addr6, dst, INET6_ADDRSTRLEN)); + ASSERT_EQ(0, strcmp("fe80::2acf:daff:fedd:342a", dst)); + + ASSERT_EQ(0, uv_ip_name(addr, dst, INET6_ADDRSTRLEN)); + ASSERT_EQ(0, strcmp("fe80::2acf:daff:fedd:342a", dst)); /* test other sa_family */ addr->sa_family = AF_UNIX; /* size is not a concern here */ ASSERT_EQ(UV_EAFNOSUPPORT, uv_ip_name(addr, dst, INET6_ADDRSTRLEN)); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-ip4-addr.c b/test/test-ip4-addr.c index 4a16c83..dfefb0f 100644 --- a/test/test-ip4-addr.c +++ b/test/test-ip4-addr.c @@ -30,26 +30,26 @@ TEST_IMPL(ip4_addr) { struct sockaddr_in addr; char dst[16]; - ASSERT_OK(uv_inet_ntop(AF_INET, "\xFF\xFF\xFF\xFF", dst, sizeof(dst))); - ASSERT_OK(strcmp(dst, "255.255.255.255")); - ASSERT_EQ(UV_ENOSPC, uv_inet_ntop(AF_INET, "\xFF\xFF\xFF\xFF", - dst, sizeof(dst) - 1)); - - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); - ASSERT_OK(uv_ip4_addr("255.255.255.255", TEST_PORT, &addr)); - ASSERT_EQ(UV_EINVAL, uv_ip4_addr("255.255.255*000", TEST_PORT, &addr)); - ASSERT_EQ(UV_EINVAL, uv_ip4_addr("255.255.255.256", TEST_PORT, &addr)); - ASSERT_EQ(UV_EINVAL, uv_ip4_addr("2555.0.0.0", TEST_PORT, &addr)); - ASSERT_EQ(UV_EINVAL, uv_ip4_addr("255", TEST_PORT, &addr)); + ASSERT(0 == uv_inet_ntop(AF_INET, "\xFF\xFF\xFF\xFF", dst, sizeof(dst))); + ASSERT(0 == strcmp(dst, "255.255.255.255")); + ASSERT(UV_ENOSPC == uv_inet_ntop(AF_INET, "\xFF\xFF\xFF\xFF", + dst, sizeof(dst) - 1)); + + ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); + ASSERT(0 == uv_ip4_addr("255.255.255.255", TEST_PORT, &addr)); + ASSERT(UV_EINVAL == uv_ip4_addr("255.255.255*000", TEST_PORT, &addr)); + ASSERT(UV_EINVAL == uv_ip4_addr("255.255.255.256", TEST_PORT, &addr)); + ASSERT(UV_EINVAL == uv_ip4_addr("2555.0.0.0", TEST_PORT, &addr)); + ASSERT(UV_EINVAL == uv_ip4_addr("255", TEST_PORT, &addr)); #ifdef SIN6_LEN - ASSERT_EQ(addr.sin_len, sizeof(addr)); + ASSERT(addr.sin_len == sizeof(addr)); #endif /* for broken address family */ - ASSERT_EQ(UV_EAFNOSUPPORT, uv_inet_pton(42, "127.0.0.1", - &addr.sin_addr.s_addr)); + ASSERT(UV_EAFNOSUPPORT == uv_inet_pton(42, "127.0.0.1", + &addr.sin_addr.s_addr)); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-ip6-addr.c b/test/test-ip6-addr.c index 632b792..8036c4b 100644 --- a/test/test-ip6-addr.c +++ b/test/test-ip6-addr.c @@ -51,7 +51,7 @@ TEST_IMPL(ip6_addr_link_local) { int ix; int r; - ASSERT_OK(uv_interface_addresses(&addresses, &count)); + ASSERT(0 == uv_interface_addresses(&addresses, &count)); for (ix = 0; ix < count; ix++) { address = addresses + ix; @@ -59,10 +59,10 @@ TEST_IMPL(ip6_addr_link_local) { if (address->address.address6.sin6_family != AF_INET6) continue; - ASSERT_OK(uv_inet_ntop(AF_INET6, - &address->address.address6.sin6_addr, - string_address, - sizeof(string_address))); + ASSERT(0 == uv_inet_ntop(AF_INET6, + &address->address.address6.sin6_addr, + string_address, + sizeof(string_address))); /* Skip addresses that are not link-local. */ if (strncmp(string_address, "fe80::", 6) != 0) @@ -72,23 +72,21 @@ TEST_IMPL(ip6_addr_link_local) { device_name = address->name; scoped_addr_len = sizeof(scoped_addr); - ASSERT_OK(uv_if_indextoname(iface_index, - scoped_addr, - &scoped_addr_len)); + ASSERT(0 == uv_if_indextoname(iface_index, scoped_addr, &scoped_addr_len)); #ifndef _WIN32 /* This assert fails on Windows, as Windows semantics are different. */ - ASSERT_OK(strcmp(device_name, scoped_addr)); + ASSERT(0 == strcmp(device_name, scoped_addr)); #endif interface_id_len = sizeof(interface_id); r = uv_if_indextoiid(iface_index, interface_id, &interface_id_len); - ASSERT_OK(r); + ASSERT(0 == r); #ifdef _WIN32 /* On Windows, the interface identifier is the numeric string of the index. */ - ASSERT_EQ(strtoul(interface_id, NULL, 10), iface_index); + ASSERT(strtoul(interface_id, NULL, 10) == iface_index); #else /* On Unix/Linux, the interface identifier is the interface device name. */ - ASSERT_OK(strcmp(device_name, interface_id)); + ASSERT(0 == strcmp(device_name, interface_id)); #endif snprintf(scoped_addr, @@ -104,20 +102,18 @@ TEST_IMPL(ip6_addr_link_local) { device_name); fflush(stderr); - ASSERT_OK(uv_ip6_addr(scoped_addr, TEST_PORT, &addr)); - fprintf(stderr, "Got scope_id 0x%2x\n", (unsigned)addr.sin6_scope_id); + ASSERT(0 == uv_ip6_addr(scoped_addr, TEST_PORT, &addr)); + fprintf(stderr, "Got scope_id 0x%02x\n", addr.sin6_scope_id); fflush(stderr); - ASSERT_EQ(iface_index, addr.sin6_scope_id); + ASSERT(iface_index == addr.sin6_scope_id); } uv_free_interface_addresses(addresses, count); scoped_addr_len = sizeof(scoped_addr); - ASSERT_NE(0, uv_if_indextoname((unsigned int)-1, - scoped_addr, - &scoped_addr_len)); + ASSERT(0 != uv_if_indextoname((unsigned int)-1, scoped_addr, &scoped_addr_len)); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -141,16 +137,16 @@ TEST_IMPL(ip6_addr_link_local) { X("ffff:ffff:ffff:ffff:ffff:ffff:255.255.255.255.255") \ #define TEST_GOOD(ADDR) \ - ASSERT_OK(uv_inet_pton(AF_INET6, ADDR, &addr)); \ - ASSERT_OK(uv_inet_pton(AF_INET6, ADDR "%en1", &addr)); \ - ASSERT_OK(uv_inet_pton(AF_INET6, ADDR "%%%%", &addr)); \ - ASSERT_OK(uv_inet_pton(AF_INET6, ADDR "%en1:1.2.3.4", &addr)); \ + ASSERT(0 == uv_inet_pton(AF_INET6, ADDR, &addr)); \ + ASSERT(0 == uv_inet_pton(AF_INET6, ADDR "%en1", &addr)); \ + ASSERT(0 == uv_inet_pton(AF_INET6, ADDR "%%%%", &addr)); \ + ASSERT(0 == uv_inet_pton(AF_INET6, ADDR "%en1:1.2.3.4", &addr)); \ #define TEST_BAD(ADDR) \ - ASSERT_NE(0, uv_inet_pton(AF_INET6, ADDR, &addr)); \ - ASSERT_NE(0, uv_inet_pton(AF_INET6, ADDR "%en1", &addr)); \ - ASSERT_NE(0, uv_inet_pton(AF_INET6, ADDR "%%%%", &addr)); \ - ASSERT_NE(0, uv_inet_pton(AF_INET6, ADDR "%en1:1.2.3.4", &addr)); \ + ASSERT(0 != uv_inet_pton(AF_INET6, ADDR, &addr)); \ + ASSERT(0 != uv_inet_pton(AF_INET6, ADDR "%en1", &addr)); \ + ASSERT(0 != uv_inet_pton(AF_INET6, ADDR "%%%%", &addr)); \ + ASSERT(0 != uv_inet_pton(AF_INET6, ADDR "%en1:1.2.3.4", &addr)); \ TEST_IMPL(ip6_pton) { struct in6_addr addr; @@ -158,7 +154,7 @@ TEST_IMPL(ip6_pton) { GOOD_ADDR_LIST(TEST_GOOD) BAD_ADDR_LIST(TEST_BAD) - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -167,9 +163,9 @@ TEST_IMPL(ip6_pton) { TEST_IMPL(ip6_sin6_len) { struct sockaddr_in6 s; - ASSERT_OK(uv_ip6_addr("::", 0, &s)); + ASSERT_EQ(0, uv_ip6_addr("::", 0, &s)); #ifdef SIN6_LEN - ASSERT_EQ(s.sin6_len, sizeof(s)); + ASSERT(s.sin6_len == sizeof(s)); #endif return 0; } diff --git a/test/test-ipc-heavy-traffic-deadlock-bug.c b/test/test-ipc-heavy-traffic-deadlock-bug.c index 0305500..89b977d 100644 --- a/test/test-ipc-heavy-traffic-deadlock-bug.c +++ b/test/test-ipc-heavy-traffic-deadlock-bug.c @@ -49,7 +49,7 @@ static size_t bytes_read; static void write_cb(uv_write_t* req, int status) { struct write_info* write_info = container_of(req, struct write_info, write_req); - ASSERT_OK(status); + ASSERT(status == 0); bytes_written += BUFFERS_PER_WRITE * BUFFER_SIZE; free(write_info); } @@ -75,7 +75,7 @@ static void do_write(uv_stream_t* handle) { r = uv_write( &write_info->write_req, handle, bufs, BUFFERS_PER_WRITE, write_cb); - ASSERT_OK(r); + ASSERT(r == 0); } static void alloc_cb(uv_handle_t* handle, @@ -94,18 +94,18 @@ static void read_cb(uv_stream_t* handle, ssize_t nread, const uv_buf_t* buf) { ssize_t i; int r; - ASSERT_GE(nread, 0); + ASSERT(nread >= 0); bytes_read += nread; for (i = 0; i < nread; i++) - ASSERT_EQ(buf->base[i], BUFFER_CONTENT); + ASSERT(buf->base[i] == BUFFER_CONTENT); free(buf->base); if (bytes_read >= XFER_SIZE) { r = uv_read_stop(handle); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_shutdown(&shutdown_req, handle, shutdown_cb); - ASSERT_OK(r); + ASSERT(r == 0); } } @@ -121,13 +121,13 @@ static void do_writes_and_reads(uv_stream_t* handle) { } r = uv_read_start(handle, alloc_cb, read_cb); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_run(handle->loop, UV_RUN_DEFAULT); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_EQ(bytes_written, XFER_SIZE); - ASSERT_EQ(bytes_read, XFER_SIZE); + ASSERT(bytes_written == XFER_SIZE); + ASSERT(bytes_read == XFER_SIZE); } TEST_IMPL(ipc_heavy_traffic_deadlock_bug) { @@ -137,7 +137,7 @@ TEST_IMPL(ipc_heavy_traffic_deadlock_bug) { spawn_helper(&pipe, &process, "ipc_helper_heavy_traffic_deadlock_bug"); do_writes_and_reads((uv_stream_t*) &pipe); - MAKE_VALGRIND_HAPPY(pipe.loop); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -146,14 +146,14 @@ int ipc_helper_heavy_traffic_deadlock_bug(void) { int r; r = uv_pipe_init(uv_default_loop(), &pipe, 1); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_pipe_open(&pipe, 0); - ASSERT_OK(r); + ASSERT(r == 0); notify_parent_process(); do_writes_and_reads((uv_stream_t*) &pipe); uv_sleep(100); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-ipc-send-recv.c b/test/test-ipc-send-recv.c index 0cdd881..8a0e970 100644 --- a/test/test-ipc-send-recv.c +++ b/test/test-ipc-send-recv.c @@ -76,12 +76,10 @@ static int write2_cb_called; static void alloc_cb(uv_handle_t* handle, size_t suggested_size, uv_buf_t* buf) { - /* We're not actually reading anything so a small buffer is okay - * but it needs to be heap-allocated to appease TSan. - */ - buf->len = 8; - buf->base = malloc(buf->len); - ASSERT_NOT_NULL(buf->base); + /* we're not actually reading anything so a small buffer is okay */ + static char slab[8]; + buf->base = slab; + buf->len = sizeof(slab); } @@ -93,10 +91,8 @@ static void recv_cb(uv_stream_t* handle, int r; union handles* recv; - free(buf->base); - pipe = (uv_pipe_t*) handle; - ASSERT_PTR_EQ(pipe, &ctx.channel); + ASSERT(pipe == &ctx.channel); do { if (++recv_cb_count == 1) { @@ -112,13 +108,13 @@ static void recv_cb(uv_stream_t* handle, * acceptable value. */ if (nread == UV_EOF) { /* UV_EOF is only acceptable for the final recv_cb call */ - ASSERT_EQ(2, recv_cb_count); + ASSERT(recv_cb_count == 2); } else { - ASSERT_GE(nread, 0); - ASSERT_GT(uv_pipe_pending_count(pipe), 0); + ASSERT(nread >= 0); + ASSERT(uv_pipe_pending_count(pipe) > 0); pending = uv_pipe_pending_type(pipe); - ASSERT_EQ(pending, ctx.expected_type); + ASSERT(pending == ctx.expected_type); if (pending == UV_NAMED_PIPE) r = uv_pipe_init(ctx.channel.loop, &recv->pipe, 0); @@ -126,10 +122,10 @@ static void recv_cb(uv_stream_t* handle, r = uv_tcp_init(ctx.channel.loop, &recv->tcp); else abort(); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_accept(handle, &recv->stream); - ASSERT_OK(r); + ASSERT(r == 0); } } while (uv_pipe_pending_count(pipe) > 0); @@ -143,8 +139,8 @@ static void connect_cb(uv_connect_t* req, int status) { int r; uv_buf_t buf; - ASSERT_PTR_EQ(req, &ctx.connect_req); - ASSERT_OK(status); + ASSERT(req == &ctx.connect_req); + ASSERT(status == 0); buf = uv_buf_init(".", 1); r = uv_write2(&ctx.write_req, @@ -152,7 +148,7 @@ static void connect_cb(uv_connect_t* req, int status) { &buf, 1, &ctx.send.stream, NULL); - ASSERT_OK(r); + ASSERT(r == 0); /* Perform two writes to the same pipe to make sure that on Windows we are * not running into issue 505: @@ -163,10 +159,10 @@ static void connect_cb(uv_connect_t* req, int status) { &buf, 1, &ctx.send2.stream, NULL); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_read_start((uv_stream_t*)&ctx.channel, alloc_cb, recv_cb); - ASSERT_OK(r); + ASSERT(r == 0); } static int run_test(int inprocess) { @@ -176,12 +172,12 @@ static int run_test(int inprocess) { if (inprocess) { r = uv_thread_create(&tid, ipc_send_recv_helper_threadproc, (void *) 42); - ASSERT_OK(r); + ASSERT(r == 0); uv_sleep(1000); r = uv_pipe_init(uv_default_loop(), &ctx.channel, 1); - ASSERT_OK(r); + ASSERT(r == 0); uv_pipe_connect(&ctx.connect_req, &ctx.channel, TEST_PIPENAME_3, connect_cb); } else { @@ -191,13 +187,13 @@ static int run_test(int inprocess) { } r = uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_EQ(2, recv_cb_count); + ASSERT(recv_cb_count == 2); if (inprocess) { r = uv_thread_join(&tid); - ASSERT_OK(r); + ASSERT(r == 0); } return 0; @@ -209,21 +205,21 @@ static int run_ipc_send_recv_pipe(int inprocess) { ctx.expected_type = UV_NAMED_PIPE; r = uv_pipe_init(uv_default_loop(), &ctx.send.pipe, 1); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_pipe_bind(&ctx.send.pipe, TEST_PIPENAME); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_pipe_init(uv_default_loop(), &ctx.send2.pipe, 1); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_pipe_bind(&ctx.send2.pipe, TEST_PIPENAME_2); - ASSERT_OK(r); + ASSERT(r == 0); r = run_test(inprocess); - ASSERT_OK(r); + ASSERT(r == 0); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -245,26 +241,26 @@ static int run_ipc_send_recv_tcp(int inprocess) { struct sockaddr_in addr; int r; - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); + ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); ctx.expected_type = UV_TCP; r = uv_tcp_init(uv_default_loop(), &ctx.send.tcp); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_tcp_init(uv_default_loop(), &ctx.send2.tcp); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_tcp_bind(&ctx.send.tcp, (const struct sockaddr*) &addr, 0); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_tcp_bind(&ctx.send2.tcp, (const struct sockaddr*) &addr, 0); - ASSERT_OK(r); + ASSERT(r == 0); r = run_test(inprocess); - ASSERT_OK(r); + ASSERT(r == 0); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -286,7 +282,7 @@ TEST_IMPL(ipc_send_recv_tcp_inprocess) { /* Everything here runs in a child process or second thread. */ static void write2_cb(uv_write_t* req, int status) { - ASSERT_OK(status); + ASSERT(status == 0); /* After two successful writes in the child process, allow the child * process to be closed. */ @@ -308,8 +304,6 @@ static void read_cb(uv_stream_t* handle, union handles* recv; uv_write_t* write_req; - free(rdbuf->base); - if (nread == UV_EOF || nread == UV_ECONNABORTED) { return; } @@ -317,7 +311,7 @@ static void read_cb(uv_stream_t* handle, ASSERT_GE(nread, 0); pipe = (uv_pipe_t*) handle; - ASSERT_PTR_EQ(pipe, &ctx2.channel); + ASSERT_EQ(pipe, &ctx2.channel); while (uv_pipe_pending_count(pipe) > 0) { if (++read_cb_count == 2) { @@ -337,10 +331,10 @@ static void read_cb(uv_stream_t* handle, r = uv_tcp_init(ctx2.channel.loop, &recv->tcp); else abort(); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_accept(handle, &recv->stream); - ASSERT_OK(r); + ASSERT(r == 0); wrbuf = uv_buf_init(".", 1); r = uv_write2(write_req, @@ -349,27 +343,27 @@ static void read_cb(uv_stream_t* handle, 1, &recv->stream, write2_cb); - ASSERT_OK(r); + ASSERT(r == 0); } } static void send_recv_start(void) { int r; - ASSERT_EQ(1, uv_is_readable((uv_stream_t*)&ctx2.channel)); - ASSERT_EQ(1, uv_is_writable((uv_stream_t*)&ctx2.channel)); - ASSERT_OK(uv_is_closing((uv_handle_t*)&ctx2.channel)); + ASSERT(1 == uv_is_readable((uv_stream_t*)&ctx2.channel)); + ASSERT(1 == uv_is_writable((uv_stream_t*)&ctx2.channel)); + ASSERT(0 == uv_is_closing((uv_handle_t*)&ctx2.channel)); r = uv_read_start((uv_stream_t*)&ctx2.channel, alloc_cb, read_cb); - ASSERT_OK(r); + ASSERT(r == 0); } static void listen_cb(uv_stream_t* handle, int status) { int r; - ASSERT_PTR_EQ(handle, (uv_stream_t*)&ctx2.listen); - ASSERT_OK(status); + ASSERT(handle == (uv_stream_t*)&ctx2.listen); + ASSERT(status == 0); r = uv_accept((uv_stream_t*)&ctx2.listen, (uv_stream_t*)&ctx2.channel); - ASSERT_OK(r); + ASSERT(r == 0); send_recv_start(); } @@ -382,27 +376,27 @@ int run_ipc_send_recv_helper(uv_loop_t* loop, int inprocess) { memset(&ctx2, 0, sizeof(ctx2)); r = uv_pipe_init(loop, &ctx2.listen, 0); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_pipe_init(loop, &ctx2.channel, 1); - ASSERT_OK(r); + ASSERT(r == 0); if (inprocess) { r = uv_pipe_bind(&ctx2.listen, TEST_PIPENAME_3); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_listen((uv_stream_t*)&ctx2.listen, SOMAXCONN, listen_cb); - ASSERT_OK(r); + ASSERT(r == 0); } else { r = uv_pipe_open(&ctx2.channel, 0); - ASSERT_OK(r); + ASSERT(r == 0); send_recv_start(); } notify_parent_process(); r = uv_run(loop, UV_RUN_DEFAULT); - ASSERT_OK(r); + ASSERT(r == 0); return 0; } @@ -414,9 +408,9 @@ int ipc_send_recv_helper(void) { int r; r = run_ipc_send_recv_helper(uv_default_loop(), 0); - ASSERT_OK(r); + ASSERT(r == 0); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -425,11 +419,11 @@ void ipc_send_recv_helper_threadproc(void* arg) { uv_loop_t loop; r = uv_loop_init(&loop); - ASSERT_OK(r); + ASSERT(r == 0); r = run_ipc_send_recv_helper(&loop, 1); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_loop_close(&loop); - ASSERT_OK(r); + ASSERT(r == 0); } diff --git a/test/test-ipc.c b/test/test-ipc.c index 49975d9..cf131ff 100644 --- a/test/test-ipc.c +++ b/test/test-ipc.c @@ -68,16 +68,16 @@ static void on_connection(uv_stream_t* server, int status) { if (!local_conn_accepted) { /* Accept the connection and close it. Also and close the server. */ - ASSERT_OK(status); + ASSERT_EQ(status, 0); ASSERT_PTR_EQ(&tcp_server, server); conn = malloc(sizeof(*conn)); ASSERT_NOT_NULL(conn); r = uv_tcp_init(server->loop, conn); - ASSERT_OK(r); + ASSERT_EQ(r, 0); r = uv_accept(server, (uv_stream_t*)conn); - ASSERT_OK(r); + ASSERT_EQ(r, 0); uv_close((uv_handle_t*)conn, close_server_conn_cb); uv_close((uv_handle_t*)server, NULL); @@ -91,8 +91,8 @@ static void exit_cb(uv_process_t* process, int term_signal) { printf("exit_cb\n"); exit_cb_called++; - ASSERT_OK(exit_status); - ASSERT_OK(term_signal); + ASSERT_EQ(exit_status, 0); + ASSERT_EQ(term_signal, 0); uv_close((uv_handle_t*)process, NULL); } @@ -126,14 +126,14 @@ static void make_many_connections(void) { ASSERT_NOT_NULL(conn); r = uv_tcp_init(uv_default_loop(), &conn->conn); - ASSERT_OK(r); - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); + ASSERT_EQ(r, 0); + ASSERT_EQ(0, uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); r = uv_tcp_connect(&conn->conn_req, (uv_tcp_t*) &conn->conn, (const struct sockaddr*) &addr, connect_cb); - ASSERT_OK(r); + ASSERT_EQ(r, 0); conn->conn.data = conn; } @@ -179,13 +179,13 @@ static void on_read(uv_stream_t* handle, /* Accept the pending TCP server, and start listening on it. */ ASSERT_EQ(pending, UV_TCP); r = uv_tcp_init(uv_default_loop(), &tcp_server); - ASSERT_OK(r); + ASSERT_EQ(r, 0); r = uv_accept((uv_stream_t*)pipe, (uv_stream_t*)&tcp_server); - ASSERT_OK(r); + ASSERT_EQ(r, 0); r = uv_listen((uv_stream_t*)&tcp_server, BACKLOG, on_connection); - ASSERT_OK(r); + ASSERT_EQ(r, 0); tcp_server_listening = 1; @@ -194,13 +194,13 @@ static void on_read(uv_stream_t* handle, outbuf = uv_buf_init("foobar\n", 7); r = uv_write(&write_req, (uv_stream_t*)pipe, &outbuf, 1, NULL); - ASSERT_OK(r); + ASSERT_EQ(r, 0); /* Create a bunch of connections to get both servers to accept. */ make_many_connections(); } else if (memcmp("accepted_connection\n", buf->base, nread) == 0) { /* Remote server has accepted a connection. Close the channel. */ - ASSERT_OK(uv_pipe_pending_count(pipe)); + ASSERT_EQ(0, uv_pipe_pending_count(pipe)); ASSERT_EQ(pending, UV_UNKNOWN_HANDLE); remote_conn_accepted = 1; uv_close((uv_handle_t*)&channel, NULL); @@ -248,28 +248,28 @@ static void on_read_listen_after_bound_twice(uv_stream_t* handle, /* Accept the first TCP server, and start listening on it. */ ASSERT_EQ(pending, UV_TCP); r = uv_tcp_init(uv_default_loop(), &tcp_server); - ASSERT_OK(r); + ASSERT_EQ(r, 0); r = uv_accept((uv_stream_t*)pipe, (uv_stream_t*)&tcp_server); - ASSERT_OK(r); + ASSERT_EQ(r, 0); r = uv_listen((uv_stream_t*)&tcp_server, BACKLOG, on_connection); - ASSERT_OK(r); + ASSERT_EQ(r, 0); } else if (read_cb_called == 2) { /* Accept the second TCP server, and start listening on it. */ ASSERT_EQ(pending, UV_TCP); r = uv_tcp_init(uv_default_loop(), &tcp_server2); - ASSERT_OK(r); + ASSERT_EQ(r, 0); r = uv_accept((uv_stream_t*)pipe, (uv_stream_t*)&tcp_server2); - ASSERT_OK(r); + ASSERT_EQ(r, 0); r = uv_listen((uv_stream_t*)&tcp_server2, BACKLOG, on_connection); ASSERT_EQ(r, UV_EADDRINUSE); uv_close((uv_handle_t*)&tcp_server, NULL); uv_close((uv_handle_t*)&tcp_server2, NULL); - ASSERT_OK(uv_pipe_pending_count(pipe)); + ASSERT_EQ(0, uv_pipe_pending_count(pipe)); uv_close((uv_handle_t*)&channel, NULL); } @@ -288,12 +288,12 @@ void spawn_helper(uv_pipe_t* channel, uv_stdio_container_t stdio[3]; r = uv_pipe_init(uv_default_loop(), channel, 1); - ASSERT_OK(r); - ASSERT_NE(0, channel->ipc); + ASSERT_EQ(r, 0); + ASSERT_NE(channel->ipc, 0); exepath_size = sizeof(exepath); r = uv_exepath(exepath, &exepath_size); - ASSERT_OK(r); + ASSERT_EQ(r, 0); exepath[exepath_size] = '\0'; args[0] = exepath; @@ -315,12 +315,12 @@ void spawn_helper(uv_pipe_t* channel, stdio[2].data.fd = 2; r = uv_spawn(uv_default_loop(), process, &options); - ASSERT_OK(r); + ASSERT_EQ(r, 0); } static void on_tcp_write(uv_write_t* req, int status) { - ASSERT_OK(status); + ASSERT_EQ(status, 0); ASSERT_PTR_EQ(req->handle, &tcp_connection); tcp_write_cb_called++; } @@ -385,10 +385,10 @@ static void on_read_connection(uv_stream_t* handle, /* Accept the pending TCP connection */ ASSERT_EQ(pending, UV_TCP); r = uv_tcp_init(uv_default_loop(), &tcp_connection); - ASSERT_OK(r); + ASSERT_EQ(r, 0); r = uv_accept(handle, (uv_stream_t*)&tcp_connection); - ASSERT_OK(r); + ASSERT_EQ(r, 0); /* Make sure that the expected data is correctly multiplexed. */ ASSERT_MEM_EQ("hello\n", buf->base, nread); @@ -397,10 +397,10 @@ static void on_read_connection(uv_stream_t* handle, outbuf = uv_buf_init("world\n", 6); r = uv_write(&write_req, (uv_stream_t*)&tcp_connection, &outbuf, 1, on_tcp_write); - ASSERT_OK(r); + ASSERT_EQ(r, 0); r = uv_read_start((uv_stream_t*)&tcp_connection, on_read_alloc, on_tcp_read); - ASSERT_OK(r); + ASSERT_EQ(r, 0); free(buf->base); } @@ -422,9 +422,9 @@ static int run_ipc_test(const char* helper, uv_read_cb read_cb) { uv_read_start((uv_stream_t*)&channel, on_alloc, read_cb); r = uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_OK(r); + ASSERT_EQ(r, 0); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -434,10 +434,10 @@ TEST_IMPL(ipc_listen_before_write) { RETURN_SKIP(NO_SEND_HANDLE_ON_PIPE); #endif int r = run_ipc_test("ipc_helper_listen_before_write", on_read); - ASSERT_EQ(1, local_conn_accepted); - ASSERT_EQ(1, remote_conn_accepted); - ASSERT_EQ(1, read_cb_called); - ASSERT_EQ(1, exit_cb_called); + ASSERT_EQ(local_conn_accepted, 1); + ASSERT_EQ(remote_conn_accepted, 1); + ASSERT_EQ(read_cb_called, 1); + ASSERT_EQ(exit_cb_called, 1); return r; } @@ -447,10 +447,10 @@ TEST_IMPL(ipc_listen_after_write) { RETURN_SKIP(NO_SEND_HANDLE_ON_PIPE); #endif int r = run_ipc_test("ipc_helper_listen_after_write", on_read); - ASSERT_EQ(1, local_conn_accepted); - ASSERT_EQ(1, remote_conn_accepted); - ASSERT_EQ(1, read_cb_called); - ASSERT_EQ(1, exit_cb_called); + ASSERT_EQ(local_conn_accepted, 1); + ASSERT_EQ(remote_conn_accepted, 1); + ASSERT_EQ(read_cb_called, 1); + ASSERT_EQ(exit_cb_called, 1); return r; } @@ -460,10 +460,10 @@ TEST_IMPL(ipc_tcp_connection) { RETURN_SKIP(NO_SEND_HANDLE_ON_PIPE); #endif int r = run_ipc_test("ipc_helper_tcp_connection", on_read_connection); - ASSERT_EQ(1, read_cb_called); - ASSERT_EQ(1, tcp_write_cb_called); - ASSERT_EQ(1, tcp_read_cb_called); - ASSERT_EQ(1, exit_cb_called); + ASSERT_EQ(read_cb_called, 1); + ASSERT_EQ(tcp_write_cb_called, 1); + ASSERT_EQ(tcp_read_cb_called, 1); + ASSERT_EQ(exit_cb_called, 1); return r; } @@ -474,22 +474,22 @@ TEST_IMPL(listen_with_simultaneous_accepts) { int r; struct sockaddr_in addr; - ASSERT_OK(uv_ip4_addr("0.0.0.0", TEST_PORT, &addr)); + ASSERT_EQ(0, uv_ip4_addr("0.0.0.0", TEST_PORT, &addr)); r = uv_tcp_init(uv_default_loop(), &server); - ASSERT_OK(r); + ASSERT_EQ(r, 0); r = uv_tcp_bind(&server, (const struct sockaddr*) &addr, 0); - ASSERT_OK(r); + ASSERT_EQ(r, 0); r = uv_tcp_simultaneous_accepts(&server, 1); - ASSERT_OK(r); + ASSERT_EQ(r, 0); r = uv_listen((uv_stream_t*)&server, SOMAXCONN, NULL); - ASSERT_OK(r); - ASSERT_EQ(32, server.reqs_pending); + ASSERT_EQ(r, 0); + ASSERT_EQ(server.reqs_pending, 32); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -499,22 +499,22 @@ TEST_IMPL(listen_no_simultaneous_accepts) { int r; struct sockaddr_in addr; - ASSERT_OK(uv_ip4_addr("0.0.0.0", TEST_PORT, &addr)); + ASSERT_EQ(0, uv_ip4_addr("0.0.0.0", TEST_PORT, &addr)); r = uv_tcp_init(uv_default_loop(), &server); - ASSERT_OK(r); + ASSERT_EQ(r, 0); r = uv_tcp_bind(&server, (const struct sockaddr*) &addr, 0); - ASSERT_OK(r); + ASSERT_EQ(r, 0); r = uv_tcp_simultaneous_accepts(&server, 0); - ASSERT_OK(r); + ASSERT_EQ(r, 0); r = uv_listen((uv_stream_t*)&server, SOMAXCONN, NULL); - ASSERT_OK(r); - ASSERT_EQ(1, server.reqs_pending); + ASSERT_EQ(r, 0); + ASSERT_EQ(server.reqs_pending, 1); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -523,8 +523,8 @@ TEST_IMPL(ipc_listen_after_bind_twice) { RETURN_SKIP(NO_SEND_HANDLE_ON_PIPE); #endif int r = run_ipc_test("ipc_helper_bind_twice", on_read_listen_after_bound_twice); - ASSERT_EQ(2, read_cb_called); - ASSERT_EQ(1, exit_cb_called); + ASSERT_EQ(read_cb_called, 2); + ASSERT_EQ(exit_cb_called, 1); return r; } #endif @@ -532,7 +532,7 @@ TEST_IMPL(ipc_listen_after_bind_twice) { TEST_IMPL(ipc_send_zero) { int r; r = run_ipc_test("ipc_helper_send_zero", on_read_send_zero); - ASSERT_OK(r); + ASSERT_EQ(r, 0); return 0; } @@ -563,7 +563,7 @@ static void tcp_connection_write_cb(uv_write_t* req, int status) { static void send_zero_write_cb(uv_write_t* req, int status) { - ASSERT_OK(status); + ASSERT_EQ(status, 0); send_zero_write++; } @@ -591,7 +591,7 @@ static void on_tcp_child_process_read(uv_stream_t* tcp, /* Write to the socket */ outbuf = uv_buf_init("hello again\n", 12); r = uv_write(&conn.tcp_write_req, tcp, &outbuf, 1, tcp_connection_write_cb); - ASSERT_OK(r); + ASSERT_EQ(r, 0); tcp_conn_read_cb_called++; } @@ -600,9 +600,9 @@ static void on_tcp_child_process_read(uv_stream_t* tcp, static void connect_child_process_cb(uv_connect_t* req, int status) { int r; - ASSERT_OK(status); + ASSERT_EQ(status, 0); r = uv_read_start(req->handle, on_read_alloc, on_tcp_child_process_read); - ASSERT_OK(r); + ASSERT_EQ(r, 0); } @@ -615,21 +615,21 @@ static void ipc_on_connection(uv_stream_t* server, int status) { * Accept the connection and close it. Also let the other * side know. */ - ASSERT_OK(status); + ASSERT_EQ(status, 0); ASSERT_PTR_EQ(&tcp_server, server); r = uv_tcp_init(server->loop, &conn.conn); - ASSERT_OK(r); + ASSERT_EQ(r, 0); r = uv_accept(server, (uv_stream_t*)&conn.conn); - ASSERT_OK(r); + ASSERT_EQ(r, 0); uv_close((uv_handle_t*)&conn.conn, close_cb); buf = uv_buf_init("accepted_connection\n", 20); r = uv_write2(&conn_notify_req, (uv_stream_t*)&channel, &buf, 1, NULL, conn_notify_write_cb); - ASSERT_OK(r); + ASSERT_EQ(r, 0); connection_accepted = 1; } @@ -646,28 +646,28 @@ static void ipc_on_connection_tcp_conn(uv_stream_t* server, int status) { uv_buf_t buf; uv_tcp_t* conn; - ASSERT_OK(status); + ASSERT_EQ(status, 0); ASSERT_PTR_EQ(&tcp_server, server); conn = malloc(sizeof(*conn)); ASSERT_NOT_NULL(conn); r = uv_tcp_init(server->loop, conn); - ASSERT_OK(r); + ASSERT_EQ(r, 0); r = uv_accept(server, (uv_stream_t*)conn); - ASSERT_OK(r); + ASSERT_EQ(r, 0); /* Send the accepted connection to the other process */ buf = uv_buf_init("hello\n", 6); r = uv_write2(&conn_notify_req, (uv_stream_t*)&channel, &buf, 1, (uv_stream_t*)conn, NULL); - ASSERT_OK(r); + ASSERT_EQ(r, 0); r = uv_read_start((uv_stream_t*) conn, on_read_alloc, on_tcp_child_process_read); - ASSERT_OK(r); + ASSERT_EQ(r, 0); uv_close((uv_handle_t*)conn, close_and_free_cb); } @@ -682,46 +682,46 @@ int ipc_helper(int listen_after_write) { int r; uv_buf_t buf; - ASSERT_OK(uv_ip4_addr("0.0.0.0", TEST_PORT, &addr)); + ASSERT_EQ(0, uv_ip4_addr("0.0.0.0", TEST_PORT, &addr)); r = uv_pipe_init(uv_default_loop(), &channel, 1); - ASSERT_OK(r); + ASSERT_EQ(r, 0); uv_pipe_open(&channel, 0); ASSERT_EQ(1, uv_is_readable((uv_stream_t*) &channel)); ASSERT_EQ(1, uv_is_writable((uv_stream_t*) &channel)); - ASSERT_OK(uv_is_closing((uv_handle_t*) &channel)); + ASSERT_EQ(0, uv_is_closing((uv_handle_t*) &channel)); r = uv_tcp_init(uv_default_loop(), &tcp_server); - ASSERT_OK(r); + ASSERT_EQ(r, 0); r = uv_tcp_bind(&tcp_server, (const struct sockaddr*) &addr, 0); - ASSERT_OK(r); + ASSERT_EQ(r, 0); if (!listen_after_write) { r = uv_listen((uv_stream_t*)&tcp_server, BACKLOG, ipc_on_connection); - ASSERT_OK(r); + ASSERT_EQ(r, 0); } buf = uv_buf_init("hello\n", 6); r = uv_write2(&write_req, (uv_stream_t*)&channel, &buf, 1, (uv_stream_t*)&tcp_server, NULL); - ASSERT_OK(r); + ASSERT_EQ(r, 0); if (listen_after_write) { r = uv_listen((uv_stream_t*)&tcp_server, BACKLOG, ipc_on_connection); - ASSERT_OK(r); + ASSERT_EQ(r, 0); } notify_parent_process(); r = uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_OK(r); + ASSERT_EQ(r, 0); - ASSERT_EQ(1, connection_accepted); - ASSERT_EQ(3, close_cb_called); + ASSERT_EQ(connection_accepted, 1); + ASSERT_EQ(close_cb_called, 3); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -736,45 +736,45 @@ int ipc_helper_tcp_connection(void) { struct sockaddr_in addr; r = uv_pipe_init(uv_default_loop(), &channel, 1); - ASSERT_OK(r); + ASSERT_EQ(r, 0); uv_pipe_open(&channel, 0); ASSERT_EQ(1, uv_is_readable((uv_stream_t*) &channel)); ASSERT_EQ(1, uv_is_writable((uv_stream_t*) &channel)); - ASSERT_OK(uv_is_closing((uv_handle_t*) &channel)); + ASSERT_EQ(0, uv_is_closing((uv_handle_t*) &channel)); r = uv_tcp_init(uv_default_loop(), &tcp_server); - ASSERT_OK(r); + ASSERT_EQ(r, 0); - ASSERT_OK(uv_ip4_addr("0.0.0.0", TEST_PORT, &addr)); + ASSERT_EQ(0, uv_ip4_addr("0.0.0.0", TEST_PORT, &addr)); r = uv_tcp_bind(&tcp_server, (const struct sockaddr*) &addr, 0); - ASSERT_OK(r); + ASSERT_EQ(r, 0); r = uv_listen((uv_stream_t*)&tcp_server, BACKLOG, ipc_on_connection_tcp_conn); - ASSERT_OK(r); + ASSERT_EQ(r, 0); /* Make a connection to the server */ r = uv_tcp_init(uv_default_loop(), &conn.conn); - ASSERT_OK(r); + ASSERT_EQ(r, 0); - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); + ASSERT_EQ(0, uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); r = uv_tcp_connect(&conn.conn_req, (uv_tcp_t*) &conn.conn, (const struct sockaddr*) &addr, connect_child_process_cb); - ASSERT_OK(r); + ASSERT_EQ(r, 0); r = uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_OK(r); + ASSERT_EQ(r, 0); - ASSERT_EQ(1, tcp_conn_read_cb_called); - ASSERT_EQ(1, tcp_conn_write_cb_called); - ASSERT_EQ(4, close_cb_called); + ASSERT_EQ(tcp_conn_read_cb_called, 1); + ASSERT_EQ(tcp_conn_write_cb_called, 1); + ASSERT_EQ(close_cb_called, 4); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -787,40 +787,40 @@ int ipc_helper_bind_twice(void) { int r; uv_buf_t buf; - ASSERT_OK(uv_ip4_addr("0.0.0.0", TEST_PORT, &addr)); + ASSERT_EQ(0, uv_ip4_addr("0.0.0.0", TEST_PORT, &addr)); r = uv_pipe_init(uv_default_loop(), &channel, 1); - ASSERT_OK(r); + ASSERT_EQ(r, 0); uv_pipe_open(&channel, 0); ASSERT_EQ(1, uv_is_readable((uv_stream_t*) &channel)); ASSERT_EQ(1, uv_is_writable((uv_stream_t*) &channel)); - ASSERT_OK(uv_is_closing((uv_handle_t*) &channel)); + ASSERT_EQ(0, uv_is_closing((uv_handle_t*) &channel)); buf = uv_buf_init("hello\n", 6); r = uv_tcp_init(uv_default_loop(), &tcp_server); - ASSERT_OK(r); + ASSERT_EQ(r, 0); r = uv_tcp_init(uv_default_loop(), &tcp_server2); - ASSERT_OK(r); + ASSERT_EQ(r, 0); r = uv_tcp_bind(&tcp_server, (const struct sockaddr*) &addr, 0); - ASSERT_OK(r); + ASSERT_EQ(r, 0); r = uv_tcp_bind(&tcp_server2, (const struct sockaddr*) &addr, 0); - ASSERT_OK(r); + ASSERT_EQ(r, 0); r = uv_write2(&write_req, (uv_stream_t*)&channel, &buf, 1, (uv_stream_t*)&tcp_server, NULL); - ASSERT_OK(r); + ASSERT_EQ(r, 0); r = uv_write2(&write_req2, (uv_stream_t*)&channel, &buf, 1, (uv_stream_t*)&tcp_server2, NULL); - ASSERT_OK(r); + ASSERT_EQ(r, 0); r = uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_OK(r); + ASSERT_EQ(r, 0); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -831,13 +831,13 @@ int ipc_helper_send_zero(void) { zero_buf = uv_buf_init(0, 0); r = uv_pipe_init(uv_default_loop(), &channel, 0); - ASSERT_OK(r); + ASSERT_EQ(r, 0); uv_pipe_open(&channel, 0); ASSERT_EQ(1, uv_is_readable((uv_stream_t*) &channel)); ASSERT_EQ(1, uv_is_writable((uv_stream_t*) &channel)); - ASSERT_OK(uv_is_closing((uv_handle_t*) &channel)); + ASSERT_EQ(0, uv_is_closing((uv_handle_t*) &channel)); r = uv_write(&write_req, (uv_stream_t*)&channel, @@ -845,13 +845,13 @@ int ipc_helper_send_zero(void) { 1, send_zero_write_cb); - ASSERT_OK(r); + ASSERT_EQ(r, 0); r = uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_OK(r); + ASSERT_EQ(r, 0); - ASSERT_EQ(1, send_zero_write); + ASSERT_EQ(send_zero_write, 1); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-list.h b/test/test-list.h index d30f02f..33554c1 100644 --- a/test/test-list.h +++ b/test/test-list.h @@ -29,7 +29,6 @@ TEST_DECLARE (loop_alive) TEST_DECLARE (loop_close) TEST_DECLARE (loop_instant_close) TEST_DECLARE (loop_stop) -TEST_DECLARE (loop_stop_before_run) TEST_DECLARE (loop_update_time) TEST_DECLARE (loop_backend_timeout) TEST_DECLARE (loop_configure) @@ -106,7 +105,6 @@ TEST_DECLARE (tcp_write_after_connect) TEST_DECLARE (tcp_writealot) TEST_DECLARE (tcp_write_fail) TEST_DECLARE (tcp_try_write) -TEST_DECLARE (tcp_write_in_a_row) TEST_DECLARE (tcp_try_write_error) TEST_DECLARE (tcp_write_queue_order) TEST_DECLARE (tcp_open) @@ -127,8 +125,6 @@ TEST_DECLARE (tcp_bind_writable_flags) TEST_DECLARE (tcp_bind_or_listen_error_after_close) TEST_DECLARE (tcp_listen_without_bind) TEST_DECLARE (tcp_connect_error_fault) -TEST_DECLARE (tcp_connect6_error_fault) -TEST_DECLARE (tcp_connect6_link_local) TEST_DECLARE (tcp_connect_timeout) TEST_DECLARE (tcp_local_connect_timeout) TEST_DECLARE (tcp6_local_connect_timeout) @@ -188,7 +184,6 @@ TEST_DECLARE (udp_open) TEST_DECLARE (udp_open_twice) TEST_DECLARE (udp_open_bound) TEST_DECLARE (udp_open_connect) -TEST_DECLARE (udp_recv_in_a_row) #ifndef _WIN32 TEST_DECLARE (udp_send_unix) #endif @@ -197,11 +192,9 @@ TEST_DECLARE (udp_try_send) TEST_DECLARE (pipe_bind_error_addrinuse) TEST_DECLARE (pipe_bind_error_addrnotavail) TEST_DECLARE (pipe_bind_error_inval) -TEST_DECLARE (pipe_connect_close_multiple) TEST_DECLARE (pipe_connect_multiple) TEST_DECLARE (pipe_listen_without_bind) TEST_DECLARE (pipe_bind_or_listen_error_after_close) -TEST_DECLARE (pipe_overlong_path) TEST_DECLARE (pipe_connect_bad_name) TEST_DECLARE (pipe_connect_to_file) TEST_DECLARE (pipe_connect_on_prepare) @@ -227,7 +220,6 @@ TEST_DECLARE (timer_init) TEST_DECLARE (timer_again) TEST_DECLARE (timer_start_twice) TEST_DECLARE (timer_order) -TEST_DECLARE (timer_zero_timeout) TEST_DECLARE (timer_huge_timeout) TEST_DECLARE (timer_huge_repeat) TEST_DECLARE (timer_run_once) @@ -235,9 +227,6 @@ TEST_DECLARE (timer_from_check) TEST_DECLARE (timer_is_closing) TEST_DECLARE (timer_null_callback) TEST_DECLARE (timer_early_check) -TEST_DECLARE (timer_no_double_call_once) -TEST_DECLARE (timer_no_double_call_nowait) -TEST_DECLARE (timer_no_run_on_unref) TEST_DECLARE (idle_starvation) TEST_DECLARE (idle_check) TEST_DECLARE (loop_handles) @@ -286,22 +275,13 @@ TEST_DECLARE (process_title_threadsafe) TEST_DECLARE (cwd_and_chdir) TEST_DECLARE (get_memory) TEST_DECLARE (get_passwd) -TEST_DECLARE (get_passwd2) -TEST_DECLARE (get_group) TEST_DECLARE (handle_fileno) TEST_DECLARE (homedir) TEST_DECLARE (tmpdir) TEST_DECLARE (hrtime) -TEST_DECLARE (clock_gettime) TEST_DECLARE (getaddrinfo_fail) TEST_DECLARE (getaddrinfo_fail_sync) -TEST_DECLARE (getaddrinfo_basic) -TEST_DECLARE (getaddrinfo_basic_sync) -TEST_DECLARE (getaddrinfo_concurrent) TEST_DECLARE (gethostname) -TEST_DECLARE (getnameinfo_basic_ip4) -TEST_DECLARE (getnameinfo_basic_ip4_sync) -TEST_DECLARE (getnameinfo_basic_ip6) TEST_DECLARE (getsockname_tcp) TEST_DECLARE (getsockname_udp) TEST_DECLARE (gettimeofday) @@ -324,7 +304,6 @@ TEST_DECLARE (spawn_detached) TEST_DECLARE (spawn_and_kill_with_std) TEST_DECLARE (spawn_and_ping) TEST_DECLARE (spawn_preserve_env) -TEST_DECLARE (spawn_same_stdout_stderr) TEST_DECLARE (spawn_setuid_fails) TEST_DECLARE (spawn_setgid_fails) TEST_DECLARE (spawn_stdout_to_file) @@ -359,7 +338,6 @@ TEST_DECLARE (fs_async_sendfile_nodata) TEST_DECLARE (fs_mkdtemp) TEST_DECLARE (fs_mkstemp) TEST_DECLARE (fs_fstat) -TEST_DECLARE (fs_fstat_stdio) TEST_DECLARE (fs_access) TEST_DECLARE (fs_chmod) TEST_DECLARE (fs_copyfile) @@ -367,7 +345,6 @@ TEST_DECLARE (fs_unlink_readonly) #ifdef _WIN32 TEST_DECLARE (fs_unlink_archive_readonly) #endif -TEST_DECLARE (fs_chown) TEST_DECLARE (fs_link) TEST_DECLARE (fs_readlink) TEST_DECLARE (fs_realpath) @@ -388,7 +365,6 @@ TEST_DECLARE (fs_futime) TEST_DECLARE (fs_lutime) TEST_DECLARE (fs_file_open_append) TEST_DECLARE (fs_statfs) -TEST_DECLARE (fs_stat_batch_multiple) TEST_DECLARE (fs_stat_missing_path) TEST_DECLARE (fs_read_bufs) TEST_DECLARE (fs_read_file_eof) @@ -418,7 +394,6 @@ TEST_DECLARE (fs_event_stop_in_cb) TEST_DECLARE (fs_scandir_empty_dir) TEST_DECLARE (fs_scandir_non_existent_dir) TEST_DECLARE (fs_scandir_file) -TEST_DECLARE (fs_scandir_early_exit) TEST_DECLARE (fs_open_dir) TEST_DECLARE (fs_readdir_empty_dir) TEST_DECLARE (fs_readdir_file) @@ -444,21 +419,17 @@ TEST_DECLARE (fs_file_flag_no_buffering) TEST_DECLARE (fs_open_readonly_acl) TEST_DECLARE (fs_fchmod_archive_readonly) TEST_DECLARE (fs_invalid_mkdir_name) -TEST_DECLARE (fs_wtf) #endif TEST_DECLARE (fs_get_system_error) TEST_DECLARE (strscpy) -TEST_DECLARE (strtok) TEST_DECLARE (threadpool_queue_work_simple) TEST_DECLARE (threadpool_queue_work_einval) -TEST_DECLARE (threadpool_multiple_event_loops) TEST_DECLARE (threadpool_cancel_getaddrinfo) TEST_DECLARE (threadpool_cancel_getnameinfo) TEST_DECLARE (threadpool_cancel_random) TEST_DECLARE (threadpool_cancel_work) TEST_DECLARE (threadpool_cancel_fs) TEST_DECLARE (threadpool_cancel_single) -TEST_DECLARE (threadpool_cancel_when_busy) TEST_DECLARE (thread_local_storage) TEST_DECLARE (thread_stack_size) TEST_DECLARE (thread_stack_size_explicit) @@ -468,8 +439,6 @@ TEST_DECLARE (thread_rwlock) TEST_DECLARE (thread_rwlock_trylock) TEST_DECLARE (thread_create) TEST_DECLARE (thread_equal) -TEST_DECLARE (thread_affinity) -TEST_DECLARE (thread_priority) TEST_DECLARE (dlerror) #if (defined(__unix__) || (defined(__APPLE__) && defined(__MACH__))) && \ !defined(__sun) @@ -506,14 +475,10 @@ TEST_DECLARE (listen_with_simultaneous_accepts) TEST_DECLARE (listen_no_simultaneous_accepts) TEST_DECLARE (fs_stat_root) TEST_DECLARE (spawn_with_an_odd_path) -TEST_DECLARE (spawn_no_path) -TEST_DECLARE (spawn_no_ext) -TEST_DECLARE (spawn_path_no_ext) TEST_DECLARE (ipc_listen_after_bind_twice) TEST_DECLARE (win32_signum_number) #else TEST_DECLARE (emfile) -TEST_DECLARE (spawn_setuid_setgid) TEST_DECLARE (we_get_signal) TEST_DECLARE (we_get_signals) TEST_DECLARE (we_get_signal_one_shot) @@ -550,7 +515,6 @@ TEST_DECLARE (fork_socketpair) TEST_DECLARE (fork_socketpair_started) TEST_DECLARE (fork_signal_to_child) TEST_DECLARE (fork_signal_to_child_closed) -TEST_DECLARE (fork_close_signal_in_child) #ifndef __APPLE__ /* This is forbidden in a fork child: The process has forked and you cannot use this CoreFoundation functionality safely. You MUST exec(). */ @@ -568,8 +532,6 @@ TEST_DECLARE (utf8_decode1) TEST_DECLARE (utf8_decode1_overrun) TEST_DECLARE (uname) -TEST_DECLARE (metrics_info_check) -TEST_DECLARE (metrics_pool_events) TEST_DECLARE (metrics_idle_time) TEST_DECLARE (metrics_idle_time_thread) TEST_DECLARE (metrics_idle_time_zero) @@ -585,7 +547,6 @@ TASK_LIST_START TEST_ENTRY (loop_close) TEST_ENTRY (loop_instant_close) TEST_ENTRY (loop_stop) - TEST_ENTRY (loop_stop_before_run) TEST_ENTRY (loop_update_time) TEST_ENTRY (loop_backend_timeout) TEST_ENTRY (loop_configure) @@ -698,7 +659,6 @@ TASK_LIST_START TEST_HELPER (tcp_write_fail, tcp4_echo_server) TEST_ENTRY (tcp_try_write) - TEST_ENTRY (tcp_write_in_a_row) TEST_ENTRY (tcp_try_write_error) TEST_ENTRY (tcp_write_queue_order) @@ -733,8 +693,6 @@ TASK_LIST_START TEST_ENTRY (tcp_bind_or_listen_error_after_close) TEST_ENTRY (tcp_listen_without_bind) TEST_ENTRY (tcp_connect_error_fault) - TEST_ENTRY (tcp_connect6_error_fault) - TEST_ENTRY (tcp_connect6_link_local) TEST_ENTRY (tcp_connect_timeout) TEST_ENTRY (tcp_local_connect_timeout) TEST_ENTRY (tcp6_local_connect_timeout) @@ -798,7 +756,6 @@ TASK_LIST_START TEST_ENTRY (udp_multicast_ttl) TEST_ENTRY (udp_sendmmsg_error) TEST_ENTRY (udp_try_send) - TEST_ENTRY (udp_recv_in_a_row) TEST_ENTRY (udp_open) TEST_ENTRY (udp_open_twice) @@ -811,11 +768,9 @@ TASK_LIST_START TEST_ENTRY (pipe_bind_error_addrinuse) TEST_ENTRY (pipe_bind_error_addrnotavail) TEST_ENTRY (pipe_bind_error_inval) - TEST_ENTRY (pipe_connect_close_multiple) TEST_ENTRY (pipe_connect_multiple) TEST_ENTRY (pipe_listen_without_bind) TEST_ENTRY (pipe_bind_or_listen_error_after_close) - TEST_ENTRY (pipe_overlong_path) TEST_ENTRY (pipe_getsockname) TEST_ENTRY (pipe_getsockname_abstract) TEST_ENTRY (pipe_getsockname_blocking) @@ -852,7 +807,6 @@ TASK_LIST_START TEST_ENTRY (timer_again) TEST_ENTRY (timer_start_twice) TEST_ENTRY (timer_order) - TEST_ENTRY (timer_zero_timeout) TEST_ENTRY (timer_huge_timeout) TEST_ENTRY (timer_huge_repeat) TEST_ENTRY (timer_run_once) @@ -860,9 +814,6 @@ TASK_LIST_START TEST_ENTRY (timer_is_closing) TEST_ENTRY (timer_null_callback) TEST_ENTRY (timer_early_check) - TEST_ENTRY (timer_no_double_call_once) - TEST_ENTRY (timer_no_double_call_nowait) - TEST_ENTRY (timer_no_run_on_unref) TEST_ENTRY (idle_starvation) TEST_ENTRY (idle_check) @@ -922,8 +873,6 @@ TASK_LIST_START TEST_ENTRY (get_memory) TEST_ENTRY (get_passwd) - TEST_ENTRY (get_passwd2) - TEST_ENTRY (get_group) TEST_ENTRY (get_loadavg) @@ -935,21 +884,11 @@ TASK_LIST_START TEST_ENTRY_CUSTOM (hrtime, 0, 0, 20000) - TEST_ENTRY (clock_gettime) - TEST_ENTRY_CUSTOM (getaddrinfo_fail, 0, 0, 10000) TEST_ENTRY_CUSTOM (getaddrinfo_fail_sync, 0, 0, 10000) - TEST_ENTRY (getaddrinfo_basic) - TEST_ENTRY (getaddrinfo_basic_sync) - TEST_ENTRY (getaddrinfo_concurrent) - TEST_ENTRY (gethostname) - TEST_ENTRY (getnameinfo_basic_ip4) - TEST_ENTRY (getnameinfo_basic_ip4_sync) - TEST_ENTRY (getnameinfo_basic_ip6) - TEST_ENTRY (getsockname_tcp) TEST_ENTRY (getsockname_udp) @@ -989,7 +928,6 @@ TASK_LIST_START TEST_ENTRY (spawn_and_kill_with_std) TEST_ENTRY (spawn_and_ping) TEST_ENTRY (spawn_preserve_env) - TEST_ENTRY (spawn_same_stdout_stderr) TEST_ENTRY (spawn_setuid_fails) TEST_ENTRY (spawn_setgid_fails) TEST_ENTRY (spawn_stdout_to_file) @@ -1028,14 +966,10 @@ TASK_LIST_START TEST_ENTRY (listen_no_simultaneous_accepts) TEST_ENTRY (fs_stat_root) TEST_ENTRY (spawn_with_an_odd_path) - TEST_ENTRY (spawn_no_path) - TEST_ENTRY (spawn_no_ext) - TEST_ENTRY (spawn_path_no_ext) TEST_ENTRY (ipc_listen_after_bind_twice) TEST_ENTRY (win32_signum_number) #else TEST_ENTRY (emfile) - TEST_ENTRY (spawn_setuid_setgid) TEST_ENTRY (we_get_signal) TEST_ENTRY (we_get_signals) TEST_ENTRY (we_get_signal_one_shot) @@ -1062,7 +996,6 @@ TASK_LIST_START TEST_ENTRY (fs_mkdtemp) TEST_ENTRY (fs_mkstemp) TEST_ENTRY (fs_fstat) - TEST_ENTRY (fs_fstat_stdio) TEST_ENTRY (fs_access) TEST_ENTRY (fs_chmod) TEST_ENTRY (fs_copyfile) @@ -1070,8 +1003,6 @@ TASK_LIST_START #ifdef _WIN32 TEST_ENTRY (fs_unlink_archive_readonly) #endif - TEST_ENTRY (fs_chown) - TEST_ENTRY (fs_link) TEST_ENTRY (fs_utime) TEST_ENTRY (fs_utime_round) TEST_ENTRY (fs_futime) @@ -1090,7 +1021,6 @@ TASK_LIST_START TEST_ENTRY (fs_fd_hash) #endif TEST_ENTRY (fs_statfs) - TEST_ENTRY (fs_stat_batch_multiple) TEST_ENTRY (fs_stat_missing_path) TEST_ENTRY (fs_read_bufs) TEST_ENTRY (fs_read_file_eof) @@ -1121,7 +1051,6 @@ TASK_LIST_START TEST_ENTRY (fs_scandir_empty_dir) TEST_ENTRY (fs_scandir_non_existent_dir) TEST_ENTRY (fs_scandir_file) - TEST_ENTRY (fs_scandir_early_exit) TEST_ENTRY (fs_open_dir) TEST_ENTRY (fs_readdir_empty_dir) TEST_ENTRY (fs_readdir_file) @@ -1145,23 +1074,19 @@ TASK_LIST_START TEST_ENTRY (fs_open_readonly_acl) TEST_ENTRY (fs_fchmod_archive_readonly) TEST_ENTRY (fs_invalid_mkdir_name) - TEST_ENTRY (fs_wtf) #endif TEST_ENTRY (fs_get_system_error) TEST_ENTRY (get_osfhandle_valid_handle) TEST_ENTRY (open_osfhandle_valid_handle) TEST_ENTRY (strscpy) - TEST_ENTRY (strtok) TEST_ENTRY (threadpool_queue_work_simple) TEST_ENTRY (threadpool_queue_work_einval) - TEST_ENTRY_CUSTOM (threadpool_multiple_event_loops, 0, 0, 60000) TEST_ENTRY (threadpool_cancel_getaddrinfo) TEST_ENTRY (threadpool_cancel_getnameinfo) TEST_ENTRY (threadpool_cancel_random) TEST_ENTRY (threadpool_cancel_work) TEST_ENTRY (threadpool_cancel_fs) TEST_ENTRY (threadpool_cancel_single) - TEST_ENTRY (threadpool_cancel_when_busy) TEST_ENTRY (thread_local_storage) TEST_ENTRY (thread_stack_size) TEST_ENTRY (thread_stack_size_explicit) @@ -1171,8 +1096,6 @@ TASK_LIST_START TEST_ENTRY (thread_rwlock_trylock) TEST_ENTRY (thread_create) TEST_ENTRY (thread_equal) - TEST_ENTRY (thread_affinity) - TEST_ENTRY (thread_priority) TEST_ENTRY (dlerror) TEST_ENTRY (ip4_addr) TEST_ENTRY (ip6_addr_link_local) @@ -1193,7 +1116,6 @@ TASK_LIST_START TEST_ENTRY (fork_socketpair_started) TEST_ENTRY (fork_signal_to_child) TEST_ENTRY (fork_signal_to_child_closed) - TEST_ENTRY (fork_close_signal_in_child) #ifndef __APPLE__ TEST_ENTRY (fork_fs_events_child) TEST_ENTRY (fork_fs_events_child_dir) @@ -1220,8 +1142,6 @@ TASK_LIST_START TEST_ENTRY (readable_on_eof) TEST_HELPER (readable_on_eof, tcp4_echo_server) - TEST_ENTRY (metrics_info_check) - TEST_ENTRY (metrics_pool_events) TEST_ENTRY (metrics_idle_time) TEST_ENTRY (metrics_idle_time_thread) TEST_ENTRY (metrics_idle_time_zero) diff --git a/test/test-loop-alive.c b/test/test-loop-alive.c index 279cfc3..cf4d301 100644 --- a/test/test-loop-alive.c +++ b/test/test-loop-alive.c @@ -37,7 +37,7 @@ static void work_cb(uv_work_t* req) { static void after_work_cb(uv_work_t* req, int status) { ASSERT(req); - ASSERT_OK(status); + ASSERT(status == 0); } @@ -51,18 +51,17 @@ TEST_IMPL(loop_alive) { ASSERT(uv_loop_alive(uv_default_loop())); r = uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_OK(r); + ASSERT(r == 0); ASSERT(!uv_loop_alive(uv_default_loop())); /* loops with requests are alive */ r = uv_queue_work(uv_default_loop(), &work_req, work_cb, after_work_cb); - ASSERT_OK(r); + ASSERT(r == 0); ASSERT(uv_loop_alive(uv_default_loop())); r = uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_OK(r); + ASSERT(r == 0); ASSERT(!uv_loop_alive(uv_default_loop())); - MAKE_VALGRIND_HAPPY(uv_default_loop()); return 0; } diff --git a/test/test-loop-close.c b/test/test-loop-close.c index cd1b76c..f0f3e62 100644 --- a/test/test-loop-close.c +++ b/test/test-loop-close.c @@ -35,23 +35,23 @@ TEST_IMPL(loop_close) { uv_loop_t loop; loop.data = &loop; - ASSERT_OK(uv_loop_init(&loop)); - ASSERT_PTR_EQ(loop.data, (void*) &loop); + ASSERT(0 == uv_loop_init(&loop)); + ASSERT(loop.data == (void*) &loop); uv_timer_init(&loop, &timer_handle); uv_timer_start(&timer_handle, timer_cb, 100, 100); - ASSERT_EQ(UV_EBUSY, uv_loop_close(&loop)); + ASSERT(UV_EBUSY == uv_loop_close(&loop)); uv_run(&loop, UV_RUN_DEFAULT); uv_close((uv_handle_t*) &timer_handle, NULL); r = uv_run(&loop, UV_RUN_DEFAULT); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_PTR_EQ(loop.data, (void*) &loop); - ASSERT_OK(uv_loop_close(&loop)); - ASSERT_PTR_EQ(loop.data, (void*) &loop); + ASSERT(loop.data == (void*) &loop); + ASSERT(0 == uv_loop_close(&loop)); + ASSERT(loop.data == (void*) &loop); return 0; } @@ -62,16 +62,14 @@ static void loop_instant_close_work_cb(uv_work_t* req) { static void loop_instant_close_after_work_cb(uv_work_t* req, int status) { } -/* It's impossible to properly cleanup after this test because loop can't be - * closed while work has been queued. */ TEST_IMPL(loop_instant_close) { static uv_loop_t loop; static uv_work_t req; - ASSERT_OK(uv_loop_init(&loop)); - ASSERT_OK(uv_queue_work(&loop, - &req, - loop_instant_close_work_cb, - loop_instant_close_after_work_cb)); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + ASSERT(0 == uv_loop_init(&loop)); + ASSERT(0 == uv_queue_work(&loop, + &req, + loop_instant_close_work_cb, + loop_instant_close_after_work_cb)); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-loop-configure.c b/test/test-loop-configure.c index 1bc3284..d057c1e 100644 --- a/test/test-loop-configure.c +++ b/test/test-loop-configure.c @@ -24,15 +24,15 @@ static void timer_cb(uv_timer_t* handle) { TEST_IMPL(loop_configure) { uv_timer_t timer_handle; uv_loop_t loop; - ASSERT_OK(uv_loop_init(&loop)); + ASSERT(0 == uv_loop_init(&loop)); #ifdef _WIN32 - ASSERT_EQ(UV_ENOSYS, uv_loop_configure(&loop, UV_LOOP_BLOCK_SIGNAL, 0)); + ASSERT(UV_ENOSYS == uv_loop_configure(&loop, UV_LOOP_BLOCK_SIGNAL, 0)); #else - ASSERT_OK(uv_loop_configure(&loop, UV_LOOP_BLOCK_SIGNAL, SIGPROF)); + ASSERT(0 == uv_loop_configure(&loop, UV_LOOP_BLOCK_SIGNAL, SIGPROF)); #endif - ASSERT_OK(uv_timer_init(&loop, &timer_handle)); - ASSERT_OK(uv_timer_start(&timer_handle, timer_cb, 10, 0)); - ASSERT_OK(uv_run(&loop, UV_RUN_DEFAULT)); - ASSERT_OK(uv_loop_close(&loop)); + ASSERT(0 == uv_timer_init(&loop, &timer_handle)); + ASSERT(0 == uv_timer_start(&timer_handle, timer_cb, 10, 0)); + ASSERT(0 == uv_run(&loop, UV_RUN_DEFAULT)); + ASSERT(0 == uv_loop_close(&loop)); return 0; } diff --git a/test/test-loop-handles.c b/test/test-loop-handles.c index 58368bf..05cb846 100644 --- a/test/test-loop-handles.c +++ b/test/test-loop-handles.c @@ -108,7 +108,7 @@ static int idle_2_is_active = 0; static void timer_cb(uv_timer_t* handle) { - ASSERT_PTR_EQ(handle, &timer_handle); + ASSERT(handle == &timer_handle); } @@ -116,7 +116,7 @@ static void idle_2_close_cb(uv_handle_t* handle) { fprintf(stderr, "%s", "IDLE_2_CLOSE_CB\n"); fflush(stderr); - ASSERT_PTR_EQ(handle, (uv_handle_t*)&idle_2_handle); + ASSERT(handle == (uv_handle_t*)&idle_2_handle); ASSERT(idle_2_is_active); @@ -129,7 +129,7 @@ static void idle_2_cb(uv_idle_t* handle) { fprintf(stderr, "%s", "IDLE_2_CB\n"); fflush(stderr); - ASSERT_PTR_EQ(handle, &idle_2_handle); + ASSERT(handle == &idle_2_handle); idle_2_cb_called++; @@ -144,14 +144,14 @@ static void idle_1_cb(uv_idle_t* handle) { fflush(stderr); ASSERT_NOT_NULL(handle); - ASSERT_GT(idles_1_active, 0); + ASSERT(idles_1_active > 0); /* Init idle_2 and make it active */ if (!idle_2_is_active && !uv_is_closing((uv_handle_t*)&idle_2_handle)) { r = uv_idle_init(uv_default_loop(), &idle_2_handle); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_idle_start(&idle_2_handle, idle_2_cb); - ASSERT_OK(r); + ASSERT(r == 0); idle_2_is_active = 1; idle_2_cb_started++; } @@ -160,7 +160,7 @@ static void idle_1_cb(uv_idle_t* handle) { if (idle_1_cb_called % 5 == 0) { r = uv_idle_stop((uv_idle_t*)handle); - ASSERT_OK(r); + ASSERT(r == 0); idles_1_active--; } } @@ -179,7 +179,7 @@ static void idle_1_close_cb(uv_handle_t* handle) { static void prepare_1_close_cb(uv_handle_t* handle) { fprintf(stderr, "%s", "PREPARE_1_CLOSE_CB"); fflush(stderr); - ASSERT_PTR_EQ(handle, (uv_handle_t*)&prepare_1_handle); + ASSERT(handle == (uv_handle_t*)&prepare_1_handle); prepare_1_close_cb_called++; } @@ -188,7 +188,7 @@ static void prepare_1_close_cb(uv_handle_t* handle) { static void check_close_cb(uv_handle_t* handle) { fprintf(stderr, "%s", "CHECK_CLOSE_CB\n"); fflush(stderr); - ASSERT_PTR_EQ(handle, (uv_handle_t*)&check_handle); + ASSERT(handle == (uv_handle_t*)&check_handle); check_close_cb_called++; } @@ -197,7 +197,7 @@ static void check_close_cb(uv_handle_t* handle) { static void prepare_2_close_cb(uv_handle_t* handle) { fprintf(stderr, "%s", "PREPARE_2_CLOSE_CB\n"); fflush(stderr); - ASSERT_PTR_EQ(handle, (uv_handle_t*)&prepare_2_handle); + ASSERT(handle == (uv_handle_t*)&prepare_2_handle); prepare_2_close_cb_called++; } @@ -208,13 +208,13 @@ static void check_cb(uv_check_t* handle) { fprintf(stderr, "%s", "CHECK_CB\n"); fflush(stderr); - ASSERT_PTR_EQ(handle, &check_handle); + ASSERT(handle == &check_handle); if (loop_iteration < ITERATIONS) { /* Make some idle watchers active */ for (i = 0; i < 1 + (loop_iteration % IDLE_COUNT); i++) { r = uv_idle_start(&idle_1_handles[i], idle_1_cb); - ASSERT_OK(r); + ASSERT(r == 0); idles_1_active++; } @@ -244,16 +244,16 @@ static void prepare_2_cb(uv_prepare_t* handle) { fprintf(stderr, "%s", "PREPARE_2_CB\n"); fflush(stderr); - ASSERT_PTR_EQ(handle, &prepare_2_handle); + ASSERT(handle == &prepare_2_handle); /* Prepare_2 gets started by prepare_1 when (loop_iteration % 2 == 0), and it * stops itself immediately. A started watcher is not queued until the next * round, so when this callback is made (loop_iteration % 2 == 0) cannot be * true. */ - ASSERT_NE(0, loop_iteration % 2); + ASSERT(loop_iteration % 2 != 0); r = uv_prepare_stop((uv_prepare_t*)handle); - ASSERT_OK(r); + ASSERT(r == 0); prepare_2_cb_called++; } @@ -264,11 +264,11 @@ static void prepare_1_cb(uv_prepare_t* handle) { fprintf(stderr, "%s", "PREPARE_1_CB\n"); fflush(stderr); - ASSERT_PTR_EQ(handle, &prepare_1_handle); + ASSERT(handle == &prepare_1_handle); if (loop_iteration % 2 == 0) { r = uv_prepare_start(&prepare_2_handle, prepare_2_cb); - ASSERT_OK(r); + ASSERT(r == 0); } prepare_1_cb_called++; @@ -283,23 +283,23 @@ TEST_IMPL(loop_handles) { int r; r = uv_prepare_init(uv_default_loop(), &prepare_1_handle); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_prepare_start(&prepare_1_handle, prepare_1_cb); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_check_init(uv_default_loop(), &check_handle); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_check_start(&check_handle, check_cb); - ASSERT_OK(r); + ASSERT(r == 0); /* initialize only, prepare_2 is started by prepare_1_cb */ r = uv_prepare_init(uv_default_loop(), &prepare_2_handle); - ASSERT_OK(r); + ASSERT(r == 0); for (i = 0; i < IDLE_COUNT; i++) { /* initialize only, idle_1 handles are started by check_cb */ r = uv_idle_init(uv_default_loop(), &idle_1_handles[i]); - ASSERT_OK(r); + ASSERT(r == 0); } /* don't init or start idle_2, both is done by idle_1_cb */ @@ -307,31 +307,31 @@ TEST_IMPL(loop_handles) { /* The timer callback is there to keep the event loop polling unref it as it * is not supposed to keep the loop alive */ r = uv_timer_init(uv_default_loop(), &timer_handle); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_timer_start(&timer_handle, timer_cb, TIMEOUT, TIMEOUT); - ASSERT_OK(r); + ASSERT(r == 0); uv_unref((uv_handle_t*)&timer_handle); r = uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_EQ(loop_iteration, ITERATIONS); + ASSERT(loop_iteration == ITERATIONS); - ASSERT_EQ(prepare_1_cb_called, ITERATIONS); - ASSERT_EQ(1, prepare_1_close_cb_called); + ASSERT(prepare_1_cb_called == ITERATIONS); + ASSERT(prepare_1_close_cb_called == 1); - ASSERT_EQ(prepare_2_cb_called, ITERATIONS / 2); - ASSERT_EQ(1, prepare_2_close_cb_called); + ASSERT(prepare_2_cb_called == ITERATIONS / 2); + ASSERT(prepare_2_close_cb_called == 1); - ASSERT_EQ(check_cb_called, ITERATIONS); - ASSERT_EQ(1, check_close_cb_called); + ASSERT(check_cb_called == ITERATIONS); + ASSERT(check_close_cb_called == 1); /* idle_1_cb should be called a lot */ - ASSERT_EQ(idle_1_close_cb_called, IDLE_COUNT); + ASSERT(idle_1_close_cb_called == IDLE_COUNT); - ASSERT_EQ(idle_2_close_cb_called, idle_2_cb_started); - ASSERT_OK(idle_2_is_active); + ASSERT(idle_2_close_cb_called == idle_2_cb_started); + ASSERT(idle_2_is_active == 0); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-loop-stop.c b/test/test-loop-stop.c index a00a5b8..14b8c11 100644 --- a/test/test-loop-stop.c +++ b/test/test-loop-stop.c @@ -30,7 +30,7 @@ static int num_ticks = 10; static void prepare_cb(uv_prepare_t* handle) { - ASSERT_PTR_EQ(handle, &prepare_handle); + ASSERT(handle == &prepare_handle); prepare_called++; if (prepare_called == num_ticks) uv_prepare_stop(handle); @@ -38,7 +38,7 @@ static void prepare_cb(uv_prepare_t* handle) { static void timer_cb(uv_timer_t* handle) { - ASSERT_PTR_EQ(handle, &timer_handle); + ASSERT(handle == &timer_handle); timer_called++; if (timer_called == 1) uv_stop(uv_default_loop()); @@ -55,29 +55,17 @@ TEST_IMPL(loop_stop) { uv_timer_start(&timer_handle, timer_cb, 100, 100); r = uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT(r); - ASSERT_EQ(1, timer_called); + ASSERT(r != 0); + ASSERT(timer_called == 1); r = uv_run(uv_default_loop(), UV_RUN_NOWAIT); - ASSERT(r); - ASSERT_GT(prepare_called, 1); + ASSERT(r != 0); + ASSERT(prepare_called > 1); r = uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_OK(r); - ASSERT_EQ(10, timer_called); - ASSERT_EQ(10, prepare_called); + ASSERT(r == 0); + ASSERT(timer_called == 10); + ASSERT(prepare_called == 10); - MAKE_VALGRIND_HAPPY(uv_default_loop()); - return 0; -} - - -TEST_IMPL(loop_stop_before_run) { - ASSERT_OK(uv_timer_init(uv_default_loop(), &timer_handle)); - ASSERT_OK(uv_timer_start(&timer_handle, (uv_timer_cb) abort, 0, 0)); - uv_stop(uv_default_loop()); - ASSERT_NE(0, uv_run(uv_default_loop(), UV_RUN_DEFAULT)); - - MAKE_VALGRIND_HAPPY(uv_default_loop()); return 0; } diff --git a/test/test-loop-time.c b/test/test-loop-time.c index 01e44ff..087720b 100644 --- a/test/test-loop-time.c +++ b/test/test-loop-time.c @@ -28,9 +28,9 @@ TEST_IMPL(loop_update_time) { start = uv_now(uv_default_loop()); while (uv_now(uv_default_loop()) - start < 1000) - ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_NOWAIT)); + ASSERT_EQ(0, uv_run(uv_default_loop(), UV_RUN_NOWAIT)); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -46,24 +46,24 @@ TEST_IMPL(loop_backend_timeout) { /* The default loop has some internal watchers to initialize. */ loop->active_handles++; r = uv_run(loop, UV_RUN_NOWAIT); - ASSERT_EQ(1, r); + ASSERT_EQ(r, 1); loop->active_handles--; - ASSERT_OK(uv_loop_alive(loop)); + ASSERT_EQ(uv_loop_alive(loop), 0); r = uv_timer_init(loop, &timer); - ASSERT_OK(r); + ASSERT_EQ(r, 0); - ASSERT_OK(uv_loop_alive(loop)); - ASSERT_OK(uv_backend_timeout(loop)); + ASSERT_EQ(uv_loop_alive(loop), 0); + ASSERT_EQ(uv_backend_timeout(loop), 0); r = uv_timer_start(&timer, cb, 1000, 0); /* 1 sec */ - ASSERT_OK(r); - ASSERT_EQ(1000, uv_backend_timeout(loop)); + ASSERT_EQ(r, 0); + ASSERT_EQ(uv_backend_timeout(loop), 1000); r = uv_run(loop, UV_RUN_DEFAULT); - ASSERT_OK(r); - ASSERT_OK(uv_backend_timeout(loop)); + ASSERT_EQ(r, 0); + ASSERT_EQ(uv_backend_timeout(loop), 0); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-metrics.c b/test/test-metrics.c index 361fcef..f527494 100644 --- a/test/test-metrics.c +++ b/test/test-metrics.c @@ -25,17 +25,6 @@ #define UV_NS_TO_MS 1000000 -typedef struct { - uv_fs_t open_req; - uv_fs_t write_req; - uv_fs_t close_req; -} fs_reqs_t; - -static uint64_t last_events_count; -static char test_buf[] = "test-buffer\n"; -static fs_reqs_t fs_reqs; -static int pool_events_counter; - static void timer_spin_cb(uv_timer_t* handle) { uint64_t t; @@ -48,9 +37,6 @@ static void timer_spin_cb(uv_timer_t* handle) { TEST_IMPL(metrics_idle_time) { -#if defined(__OpenBSD__) - RETURN_SKIP("Test does not currently work in OpenBSD"); -#endif const uint64_t timeout = 1000; uv_timer_t timer; uint64_t idle_time; @@ -59,20 +45,20 @@ TEST_IMPL(metrics_idle_time) { cntr = 0; timer.data = &cntr; - ASSERT_OK(uv_loop_configure(uv_default_loop(), UV_METRICS_IDLE_TIME)); - ASSERT_OK(uv_timer_init(uv_default_loop(), &timer)); - ASSERT_OK(uv_timer_start(&timer, timer_spin_cb, timeout, 0)); + ASSERT_EQ(0, uv_loop_configure(uv_default_loop(), UV_METRICS_IDLE_TIME)); + ASSERT_EQ(0, uv_timer_init(uv_default_loop(), &timer)); + ASSERT_EQ(0, uv_timer_start(&timer, timer_spin_cb, timeout, 0)); - ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT)); + ASSERT_EQ(0, uv_run(uv_default_loop(), UV_RUN_DEFAULT)); ASSERT_GT(cntr, 0); idle_time = uv_metrics_idle_time(uv_default_loop()); /* Permissive check that the idle time matches within the timeout ±500 ms. */ - ASSERT_LE(idle_time, (timeout + 500) * UV_NS_TO_MS); - ASSERT_GE(idle_time, (timeout - 500) * UV_NS_TO_MS); + ASSERT((idle_time <= (timeout + 500) * UV_NS_TO_MS) && + (idle_time >= (timeout - 500) * UV_NS_TO_MS)); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -87,12 +73,12 @@ static void metrics_routine_cb(void* arg) { cntr = 0; timer.data = &cntr; - ASSERT_OK(uv_loop_init(&loop)); - ASSERT_OK(uv_loop_configure(&loop, UV_METRICS_IDLE_TIME)); - ASSERT_OK(uv_timer_init(&loop, &timer)); - ASSERT_OK(uv_timer_start(&timer, timer_spin_cb, timeout, 0)); + ASSERT_EQ(0, uv_loop_init(&loop)); + ASSERT_EQ(0, uv_loop_configure(&loop, UV_METRICS_IDLE_TIME)); + ASSERT_EQ(0, uv_timer_init(&loop, &timer)); + ASSERT_EQ(0, uv_timer_start(&timer, timer_spin_cb, timeout, 0)); - ASSERT_OK(uv_run(&loop, UV_RUN_DEFAULT)); + ASSERT_EQ(0, uv_run(&loop, UV_RUN_DEFAULT)); ASSERT_GT(cntr, 0); idle_time = uv_metrics_idle_time(&loop); @@ -104,7 +90,7 @@ static void metrics_routine_cb(void* arg) { ASSERT_GE(idle_time, (timeout - 500) * UV_NS_TO_MS); close_loop(&loop); - ASSERT_OK(uv_loop_close(&loop)); + ASSERT_EQ(0, uv_loop_close(&loop)); } @@ -113,7 +99,7 @@ TEST_IMPL(metrics_idle_time_thread) { int i; for (i = 0; i < 5; i++) { - ASSERT_OK(uv_thread_create(&threads[i], metrics_routine_cb, NULL)); + ASSERT_EQ(0, uv_thread_create(&threads[i], metrics_routine_cb, NULL)); } for (i = 0; i < 5; i++) { @@ -130,261 +116,20 @@ static void timer_noop_cb(uv_timer_t* handle) { TEST_IMPL(metrics_idle_time_zero) { - uv_metrics_t metrics; uv_timer_t timer; int cntr; cntr = 0; timer.data = &cntr; - ASSERT_OK(uv_loop_configure(uv_default_loop(), UV_METRICS_IDLE_TIME)); - ASSERT_OK(uv_timer_init(uv_default_loop(), &timer)); - ASSERT_OK(uv_timer_start(&timer, timer_noop_cb, 0, 0)); + ASSERT_EQ(0, uv_loop_configure(uv_default_loop(), UV_METRICS_IDLE_TIME)); + ASSERT_EQ(0, uv_timer_init(uv_default_loop(), &timer)); + ASSERT_EQ(0, uv_timer_start(&timer, timer_noop_cb, 0, 0)); - ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT)); + ASSERT_EQ(0, uv_run(uv_default_loop(), UV_RUN_DEFAULT)); ASSERT_GT(cntr, 0); - ASSERT_OK(uv_metrics_idle_time(uv_default_loop())); - - ASSERT_OK(uv_metrics_info(uv_default_loop(), &metrics)); - ASSERT_UINT64_EQ(cntr, metrics.loop_count); - - MAKE_VALGRIND_HAPPY(uv_default_loop()); - return 0; -} - - -static void close_cb(uv_fs_t* req) { - uv_metrics_t metrics; - - ASSERT_OK(uv_metrics_info(uv_default_loop(), &metrics)); - ASSERT_UINT64_EQ(3, metrics.loop_count); - ASSERT_UINT64_GT(metrics.events, last_events_count); - - uv_fs_req_cleanup(req); - last_events_count = metrics.events; -} - - -static void write_cb(uv_fs_t* req) { - uv_metrics_t metrics; - - ASSERT_OK(uv_metrics_info(uv_default_loop(), &metrics)); - ASSERT_UINT64_EQ(2, metrics.loop_count); - ASSERT_UINT64_GT(metrics.events, last_events_count); - ASSERT_EQ(req->result, sizeof(test_buf)); - - uv_fs_req_cleanup(req); - last_events_count = metrics.events; - - ASSERT_OK(uv_fs_close(uv_default_loop(), - &fs_reqs.close_req, - fs_reqs.open_req.result, - close_cb)); -} - - -static void create_cb(uv_fs_t* req) { - uv_metrics_t metrics; - - ASSERT_OK(uv_metrics_info(uv_default_loop(), &metrics)); - /* Event count here is still 0 so not going to check. */ - ASSERT_UINT64_EQ(1, metrics.loop_count); - ASSERT_GE(req->result, 0); - - uv_fs_req_cleanup(req); - last_events_count = metrics.events; - - uv_buf_t iov = uv_buf_init(test_buf, sizeof(test_buf)); - ASSERT_OK(uv_fs_write(uv_default_loop(), - &fs_reqs.write_req, - req->result, - &iov, - 1, - 0, - write_cb)); -} - - -static void prepare_cb(uv_prepare_t* handle) { - uv_metrics_t metrics; - - uv_prepare_stop(handle); - - ASSERT_OK(uv_metrics_info(uv_default_loop(), &metrics)); - ASSERT_UINT64_EQ(0, metrics.loop_count); - ASSERT_UINT64_EQ(0, metrics.events); - - ASSERT_OK(uv_fs_open(uv_default_loop(), - &fs_reqs.open_req, - "test_file", - UV_FS_O_WRONLY | UV_FS_O_CREAT, S_IRUSR | S_IWUSR, - create_cb)); -} - - -TEST_IMPL(metrics_info_check) { - uv_fs_t unlink_req; - uv_prepare_t prepare; - - uv_fs_unlink(NULL, &unlink_req, "test_file", NULL); - uv_fs_req_cleanup(&unlink_req); - - ASSERT_OK(uv_prepare_init(uv_default_loop(), &prepare)); - ASSERT_OK(uv_prepare_start(&prepare, prepare_cb)); - - ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT)); - - uv_fs_unlink(NULL, &unlink_req, "test_file", NULL); - uv_fs_req_cleanup(&unlink_req); - - MAKE_VALGRIND_HAPPY(uv_default_loop()); - return 0; -} - - -static void fs_prepare_cb(uv_prepare_t* handle) { - uv_metrics_t metrics; - - ASSERT_OK(uv_metrics_info(uv_default_loop(), &metrics)); - - if (pool_events_counter == 1) - ASSERT_EQ(metrics.events, metrics.events_waiting); - - if (pool_events_counter < 7) - return; - - uv_prepare_stop(handle); - pool_events_counter = -42; -} - - -static void fs_stat_cb(uv_fs_t* req) { - uv_fs_req_cleanup(req); - pool_events_counter++; -} - - -static void fs_work_cb(uv_work_t* req) { -} - - -static void fs_after_work_cb(uv_work_t* req, int status) { - free(req); - pool_events_counter++; -} - - -static void fs_write_cb(uv_fs_t* req) { - uv_work_t* work1 = malloc(sizeof(*work1)); - uv_work_t* work2 = malloc(sizeof(*work2)); - pool_events_counter++; - - uv_fs_req_cleanup(req); - - ASSERT_OK(uv_queue_work(uv_default_loop(), - work1, - fs_work_cb, - fs_after_work_cb)); - ASSERT_OK(uv_queue_work(uv_default_loop(), - work2, - fs_work_cb, - fs_after_work_cb)); -} - - -static void fs_random_cb(uv_random_t* req, int status, void* buf, size_t len) { - pool_events_counter++; -} - - -static void fs_addrinfo_cb(uv_getaddrinfo_t* req, - int status, - struct addrinfo* res) { - uv_freeaddrinfo(req->addrinfo); - pool_events_counter++; -} - + ASSERT_EQ(0, uv_metrics_idle_time(uv_default_loop())); -TEST_IMPL(metrics_pool_events) { - uv_buf_t iov; - uv_fs_t open_req; - uv_fs_t stat1_req; - uv_fs_t stat2_req; - uv_fs_t unlink_req; - uv_fs_t write_req; - uv_getaddrinfo_t addrinfo_req; - uv_metrics_t metrics; - uv_prepare_t prepare; - uv_random_t random_req; - int fd; - char rdata; - - ASSERT_OK(uv_loop_configure(uv_default_loop(), UV_METRICS_IDLE_TIME)); - - uv_fs_unlink(NULL, &unlink_req, "test_file", NULL); - uv_fs_req_cleanup(&unlink_req); - - ASSERT_OK(uv_prepare_init(uv_default_loop(), &prepare)); - ASSERT_OK(uv_prepare_start(&prepare, fs_prepare_cb)); - - pool_events_counter = 0; - fd = uv_fs_open(NULL, - &open_req, "test_file", UV_FS_O_WRONLY | UV_FS_O_CREAT, - S_IRUSR | S_IWUSR, - NULL); - ASSERT_GT(fd, 0); - uv_fs_req_cleanup(&open_req); - - iov = uv_buf_init(test_buf, sizeof(test_buf)); - ASSERT_OK(uv_fs_write(uv_default_loop(), - &write_req, - fd, - &iov, - 1, - 0, - fs_write_cb)); - ASSERT_OK(uv_fs_stat(uv_default_loop(), - &stat1_req, - "test_file", - fs_stat_cb)); - ASSERT_OK(uv_fs_stat(uv_default_loop(), - &stat2_req, - "test_file", - fs_stat_cb)); - ASSERT_OK(uv_random(uv_default_loop(), - &random_req, - &rdata, - 1, - 0, - fs_random_cb)); - ASSERT_OK(uv_getaddrinfo(uv_default_loop(), - &addrinfo_req, - fs_addrinfo_cb, - "example.invalid", - NULL, - NULL)); - - /* Sleep for a moment to hopefully force the events to complete before - * entering the event loop. */ - uv_sleep(100); - - ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT)); - - ASSERT_OK(uv_metrics_info(uv_default_loop(), &metrics)); - /* It's possible for uv__work_done() to execute one extra time even though the - * QUEUE has already been cleared out. This has to do with the way we use an - * uv_async to tell the event loop thread to process the worker pool QUEUE. */ - ASSERT_GE(metrics.events, 7); - /* It's possible one of the other events also got stuck in the event queue, so - * check GE instead of EQ. Reason for 4 instead of 5 is because the call to - * uv_getaddrinfo() is racey and slow. So can't guarantee that it'll always - * execute before sleep completes. */ - ASSERT_GE(metrics.events_waiting, 4); - ASSERT_EQ(pool_events_counter, -42); - - uv_fs_unlink(NULL, &unlink_req, "test_file", NULL); - uv_fs_req_cleanup(&unlink_req); - - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-multiple-listen.c b/test/test-multiple-listen.c index 47f35f6..0b28514 100644 --- a/test/test-multiple-listen.c +++ b/test/test-multiple-listen.c @@ -38,7 +38,7 @@ static void close_cb(uv_handle_t* handle) { static void connection_cb(uv_stream_t* tcp, int status) { - ASSERT_OK(status); + ASSERT(status == 0); uv_close((uv_handle_t*)&server, close_cb); connection_cb_called++; } @@ -48,25 +48,25 @@ static void start_server(void) { struct sockaddr_in addr; int r; - ASSERT_OK(uv_ip4_addr("0.0.0.0", TEST_PORT, &addr)); + ASSERT(0 == uv_ip4_addr("0.0.0.0", TEST_PORT, &addr)); r = uv_tcp_init(uv_default_loop(), &server); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_tcp_bind(&server, (const struct sockaddr*) &addr, 0); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_listen((uv_stream_t*)&server, 128, connection_cb); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_listen((uv_stream_t*)&server, 128, connection_cb); - ASSERT_OK(r); + ASSERT(r == 0); } static void connect_cb(uv_connect_t* req, int status) { ASSERT_NOT_NULL(req); - ASSERT_OK(status); + ASSERT(status == 0); free(req); uv_close((uv_handle_t*)&client, close_cb); connect_cb_called++; @@ -78,17 +78,17 @@ static void client_connect(void) { uv_connect_t* connect_req = malloc(sizeof *connect_req); int r; - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); + ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); ASSERT_NOT_NULL(connect_req); r = uv_tcp_init(uv_default_loop(), &client); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_tcp_connect(connect_req, &client, (const struct sockaddr*) &addr, connect_cb); - ASSERT_OK(r); + ASSERT(r == 0); } @@ -100,10 +100,10 @@ TEST_IMPL(multiple_listen) { uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_EQ(1, connection_cb_called); - ASSERT_EQ(1, connect_cb_called); - ASSERT_EQ(2, close_cb_called); + ASSERT(connection_cb_called == 1); + ASSERT(connect_cb_called == 1); + ASSERT(close_cb_called == 2); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-mutexes.c b/test/test-mutexes.c index ca33773..975222c 100644 --- a/test/test-mutexes.c +++ b/test/test-mutexes.c @@ -40,7 +40,7 @@ TEST_IMPL(thread_mutex) { int r; r = uv_mutex_init(&mutex); - ASSERT_OK(r); + ASSERT(r == 0); uv_mutex_lock(&mutex); uv_mutex_unlock(&mutex); @@ -55,11 +55,11 @@ TEST_IMPL(thread_mutex_recursive) { int r; r = uv_mutex_init_recursive(&mutex); - ASSERT_OK(r); + ASSERT(r == 0); uv_mutex_lock(&mutex); uv_mutex_lock(&mutex); - ASSERT_OK(uv_mutex_trylock(&mutex)); + ASSERT(0 == uv_mutex_trylock(&mutex)); uv_mutex_unlock(&mutex); uv_mutex_unlock(&mutex); @@ -75,7 +75,7 @@ TEST_IMPL(thread_rwlock) { int r; r = uv_rwlock_init(&rwlock); - ASSERT_OK(r); + ASSERT(r == 0); uv_rwlock_rdlock(&rwlock); uv_rwlock_rdunlock(&rwlock); @@ -101,7 +101,7 @@ static void synchronize(void) { synchronize_nowait(); /* Wait for the other thread. Guard against spurious wakeups. */ for (current = step; current == step; uv_cond_wait(&condvar, &mutex)); - ASSERT_EQ(step, current + 1); + ASSERT(step == current + 1); } @@ -111,23 +111,23 @@ static void thread_rwlock_trylock_peer(void* unused) { uv_mutex_lock(&mutex); /* Write lock held by other thread. */ - ASSERT_EQ(UV_EBUSY, uv_rwlock_tryrdlock(&rwlock)); - ASSERT_EQ(UV_EBUSY, uv_rwlock_trywrlock(&rwlock)); + ASSERT(UV_EBUSY == uv_rwlock_tryrdlock(&rwlock)); + ASSERT(UV_EBUSY == uv_rwlock_trywrlock(&rwlock)); synchronize(); /* Read lock held by other thread. */ - ASSERT_OK(uv_rwlock_tryrdlock(&rwlock)); + ASSERT(0 == uv_rwlock_tryrdlock(&rwlock)); uv_rwlock_rdunlock(&rwlock); - ASSERT_EQ(UV_EBUSY, uv_rwlock_trywrlock(&rwlock)); + ASSERT(UV_EBUSY == uv_rwlock_trywrlock(&rwlock)); synchronize(); /* Acquire write lock. */ - ASSERT_OK(uv_rwlock_trywrlock(&rwlock)); + ASSERT(0 == uv_rwlock_trywrlock(&rwlock)); synchronize(); /* Release write lock and acquire read lock. */ uv_rwlock_wrunlock(&rwlock); - ASSERT_OK(uv_rwlock_tryrdlock(&rwlock)); + ASSERT(0 == uv_rwlock_tryrdlock(&rwlock)); synchronize(); uv_rwlock_rdunlock(&rwlock); @@ -139,22 +139,22 @@ static void thread_rwlock_trylock_peer(void* unused) { TEST_IMPL(thread_rwlock_trylock) { uv_thread_t thread; - ASSERT_OK(uv_cond_init(&condvar)); - ASSERT_OK(uv_mutex_init(&mutex)); - ASSERT_OK(uv_rwlock_init(&rwlock)); + ASSERT(0 == uv_cond_init(&condvar)); + ASSERT(0 == uv_mutex_init(&mutex)); + ASSERT(0 == uv_rwlock_init(&rwlock)); uv_mutex_lock(&mutex); - ASSERT_OK(uv_thread_create(&thread, thread_rwlock_trylock_peer, NULL)); + ASSERT(0 == uv_thread_create(&thread, thread_rwlock_trylock_peer, NULL)); /* Hold write lock. */ - ASSERT_OK(uv_rwlock_trywrlock(&rwlock)); + ASSERT(0 == uv_rwlock_trywrlock(&rwlock)); synchronize(); /* Releases the mutex to the other thread. */ /* Release write lock and acquire read lock. Pthreads doesn't support * the notion of upgrading or downgrading rwlocks, so neither do we. */ uv_rwlock_wrunlock(&rwlock); - ASSERT_OK(uv_rwlock_tryrdlock(&rwlock)); + ASSERT(0 == uv_rwlock_tryrdlock(&rwlock)); synchronize(); /* Release read lock. */ @@ -162,17 +162,17 @@ TEST_IMPL(thread_rwlock_trylock) { synchronize(); /* Write lock held by other thread. */ - ASSERT_EQ(UV_EBUSY, uv_rwlock_tryrdlock(&rwlock)); - ASSERT_EQ(UV_EBUSY, uv_rwlock_trywrlock(&rwlock)); + ASSERT(UV_EBUSY == uv_rwlock_tryrdlock(&rwlock)); + ASSERT(UV_EBUSY == uv_rwlock_trywrlock(&rwlock)); synchronize(); /* Read lock held by other thread. */ - ASSERT_OK(uv_rwlock_tryrdlock(&rwlock)); + ASSERT(0 == uv_rwlock_tryrdlock(&rwlock)); uv_rwlock_rdunlock(&rwlock); - ASSERT_EQ(UV_EBUSY, uv_rwlock_trywrlock(&rwlock)); + ASSERT(UV_EBUSY == uv_rwlock_trywrlock(&rwlock)); synchronize(); - ASSERT_OK(uv_thread_join(&thread)); + ASSERT(0 == uv_thread_join(&thread)); uv_rwlock_destroy(&rwlock); uv_mutex_unlock(&mutex); uv_mutex_destroy(&mutex); diff --git a/test/test-not-readable-nor-writable-on-read-error.c b/test/test-not-readable-nor-writable-on-read-error.c index 2c45a2d..ae951e3 100644 --- a/test/test-not-readable-nor-writable-on-read-error.c +++ b/test/test-not-readable-nor-writable-on-read-error.c @@ -35,7 +35,7 @@ static int close_cb_called; static void write_cb(uv_write_t* req, int status) { write_cb_called++; - ASSERT_OK(status); + ASSERT(status == 0); } static void alloc_cb(uv_handle_t* handle, @@ -54,8 +54,8 @@ static void read_cb(uv_stream_t* handle, ssize_t nread, const uv_buf_t* buf) { read_cb_called++; ASSERT((nread < 0) && (nread != UV_EOF)); - ASSERT_OK(uv_is_writable(handle)); - ASSERT_OK(uv_is_readable(handle)); + ASSERT(0 == uv_is_writable(handle)); + ASSERT(0 == uv_is_readable(handle)); uv_close((uv_handle_t*) handle, close_cb); } @@ -65,10 +65,10 @@ static void connect_cb(uv_connect_t* req, int status) { uv_buf_t reset_me; connect_cb_called++; - ASSERT_OK(status); + ASSERT(status == 0); r = uv_read_start((uv_stream_t*) &tcp_client, alloc_cb, read_cb); - ASSERT_OK(r); + ASSERT(r == 0); reset_me = uv_buf_init(reset_me_cmd, sizeof(reset_me_cmd)); @@ -78,27 +78,27 @@ static void connect_cb(uv_connect_t* req, int status) { 1, write_cb); - ASSERT_OK(r); + ASSERT(r == 0); } TEST_IMPL(not_readable_nor_writable_on_read_error) { struct sockaddr_in sa; - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &sa)); - ASSERT_OK(uv_loop_init(&loop)); - ASSERT_OK(uv_tcp_init(&loop, &tcp_client)); + ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &sa)); + ASSERT(0 == uv_loop_init(&loop)); + ASSERT(0 == uv_tcp_init(&loop, &tcp_client)); - ASSERT_OK(uv_tcp_connect(&connect_req, - &tcp_client, - (const struct sockaddr*) &sa, - connect_cb)); + ASSERT(0 == uv_tcp_connect(&connect_req, + &tcp_client, + (const struct sockaddr*) &sa, + connect_cb)); - ASSERT_OK(uv_run(&loop, UV_RUN_DEFAULT)); + ASSERT(0 == uv_run(&loop, UV_RUN_DEFAULT)); - ASSERT_EQ(1, connect_cb_called); - ASSERT_EQ(1, read_cb_called); - ASSERT_EQ(1, write_cb_called); - ASSERT_EQ(1, close_cb_called); + ASSERT(connect_cb_called == 1); + ASSERT(read_cb_called == 1); + ASSERT(write_cb_called == 1); + ASSERT(close_cb_called == 1); - MAKE_VALGRIND_HAPPY(&loop); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-not-writable-after-shutdown.c b/test/test-not-writable-after-shutdown.c index 066f8bb..9cd9370 100644 --- a/test/test-not-writable-after-shutdown.c +++ b/test/test-not-writable-after-shutdown.c @@ -34,12 +34,12 @@ static void shutdown_cb(uv_shutdown_t* req, int status) { static void connect_cb(uv_connect_t* req, int status) { int r; - ASSERT_OK(status); + ASSERT(status == 0); r = uv_shutdown(&shutdown_req, req->handle, shutdown_cb); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_OK(uv_is_writable(req->handle)); + ASSERT(0 == uv_is_writable(req->handle)); } TEST_IMPL(not_writable_after_shutdown) { @@ -49,21 +49,21 @@ TEST_IMPL(not_writable_after_shutdown) { uv_tcp_t socket; uv_connect_t connect_req; - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); + ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); loop = uv_default_loop(); r = uv_tcp_init(loop, &socket); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_tcp_connect(&connect_req, &socket, (const struct sockaddr*) &addr, connect_cb); - ASSERT_OK(r); + ASSERT(r == 0); - r = uv_run(loop, UV_RUN_DEFAULT); - ASSERT_OK(r); + r = uv_run(uv_default_loop(), UV_RUN_DEFAULT); + ASSERT(r == 0); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-osx-select.c b/test/test-osx-select.c index 44e2c6d..a0afda9 100644 --- a/test/test-osx-select.c +++ b/test/test-osx-select.c @@ -62,7 +62,7 @@ TEST_IMPL(osx_select) { } r = uv_tty_init(uv_default_loop(), &tty, fd, 1); - ASSERT_OK(r); + ASSERT(r == 0); uv_read_start((uv_stream_t*) &tty, alloc_cb, read_cb); @@ -72,14 +72,14 @@ TEST_IMPL(osx_select) { "feel pretty happy\n"; for (i = 0, len = strlen(str); i < len; i++) { r = ioctl(fd, TIOCSTI, str + i); - ASSERT_OK(r); + ASSERT(r == 0); } uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_EQ(3, read_count); + ASSERT(read_count == 3); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -97,13 +97,13 @@ TEST_IMPL(osx_select_many_fds) { TEST_FILE_LIMIT(ARRAY_SIZE(tcps) + 100); r = uv_ip4_addr("127.0.0.1", 0, &addr); - ASSERT_OK(r); + ASSERT(r == 0); for (i = 0; i < ARRAY_SIZE(tcps); i++) { r = uv_tcp_init(uv_default_loop(), &tcps[i]); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_tcp_bind(&tcps[i], (const struct sockaddr *) &addr, 0); - ASSERT_OK(r); + ASSERT(r == 0); uv_unref((uv_handle_t*) &tcps[i]); } @@ -115,10 +115,10 @@ TEST_IMPL(osx_select_many_fds) { } r = uv_tty_init(uv_default_loop(), &tty, fd, 1); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_read_start((uv_stream_t*) &tty, alloc_cb, read_cb); - ASSERT_OK(r); + ASSERT(r == 0); /* Emulate user-input */ str = "got some input\n" @@ -126,14 +126,14 @@ TEST_IMPL(osx_select_many_fds) { "feel pretty happy\n"; for (i = 0, len = strlen(str); i < len; i++) { r = ioctl(fd, TIOCSTI, str + i); - ASSERT_OK(r); + ASSERT(r == 0); } uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_EQ(3, read_count); + ASSERT(read_count == 3); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-ping-pong.c b/test/test-ping-pong.c index cd9fbf6..c598587 100644 --- a/test/test-ping-pong.c +++ b/test/test-ping-pong.c @@ -83,7 +83,7 @@ static void pinger_on_close(uv_handle_t* handle) { static void pinger_after_write(uv_write_t* req, int status) { - ASSERT_OK(status); + ASSERT_EQ(status, 0); free(req->data); free(req); } @@ -112,7 +112,7 @@ static void pinger_write_ping(pinger_t* pinger) { req = malloc(sizeof(*req)); ASSERT_NOT_NULL(req); req->data = NULL; - ASSERT_OK(uv_write(req, stream, bufs, nbufs, pinger_after_write)); + ASSERT_EQ(0, uv_write(req, stream, bufs, nbufs, pinger_after_write)); puts("PING"); } @@ -188,7 +188,7 @@ static void ponger_read_cb(uv_stream_t* stream, req = malloc(sizeof(*req)); ASSERT_NOT_NULL(req); req->data = buf->base; - ASSERT_OK(uv_write(req, stream, &writebuf, 1, pinger_after_write)); + ASSERT_EQ(0, uv_write(req, stream, &writebuf, 1, pinger_after_write)); } @@ -197,17 +197,17 @@ static void pinger_on_connect(uv_connect_t* req, int status) { pinger_on_connect_count++; - ASSERT_OK(status); + ASSERT_EQ(status, 0); ASSERT_EQ(1, uv_is_readable(req->handle)); ASSERT_EQ(1, uv_is_writable(req->handle)); - ASSERT_OK(uv_is_closing((uv_handle_t *) req->handle)); + ASSERT_EQ(0, uv_is_closing((uv_handle_t *) req->handle)); pinger_write_ping(pinger); - ASSERT_OK(uv_read_start((uv_stream_t*) req->handle, - alloc_cb, - pinger_read_cb)); + ASSERT_EQ(0, uv_read_start((uv_stream_t*) req->handle, + alloc_cb, + pinger_read_cb)); } @@ -218,7 +218,7 @@ static void tcp_pinger_v6_new(int vectored_writes) { pinger_t* pinger; - ASSERT_OK(uv_ip6_addr("::1", TEST_PORT, &server_addr)); + ASSERT_EQ(0, uv_ip6_addr("::1", TEST_PORT, &server_addr)); pinger = malloc(sizeof(*pinger)); ASSERT_NOT_NULL(pinger); pinger->vectored_writes = vectored_writes; @@ -229,7 +229,7 @@ static void tcp_pinger_v6_new(int vectored_writes) { /* Try to connect to the server and do NUM_PINGS ping-pongs. */ r = uv_tcp_init(uv_default_loop(), &pinger->stream.tcp); pinger->stream.tcp.data = pinger; - ASSERT_OK(r); + ASSERT_EQ(0, r); /* We are never doing multiple reads/connects at a time anyway, so these * handles can be pre-initialized. */ @@ -237,10 +237,10 @@ static void tcp_pinger_v6_new(int vectored_writes) { &pinger->stream.tcp, (const struct sockaddr*) &server_addr, pinger_on_connect); - ASSERT_OK(r); + ASSERT_EQ(0, r); /* Synchronous connect callbacks are not allowed. */ - ASSERT_OK(pinger_on_connect_count); + ASSERT_EQ(pinger_on_connect_count, 0); } @@ -249,7 +249,7 @@ static void tcp_pinger_new(int vectored_writes) { struct sockaddr_in server_addr; pinger_t* pinger; - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &server_addr)); + ASSERT_EQ(0, uv_ip4_addr("127.0.0.1", TEST_PORT, &server_addr)); pinger = malloc(sizeof(*pinger)); ASSERT_NOT_NULL(pinger); pinger->vectored_writes = vectored_writes; @@ -260,7 +260,7 @@ static void tcp_pinger_new(int vectored_writes) { /* Try to connect to the server and do NUM_PINGS ping-pongs. */ r = uv_tcp_init(uv_default_loop(), &pinger->stream.tcp); pinger->stream.tcp.data = pinger; - ASSERT_OK(r); + ASSERT_EQ(0, r); /* We are never doing multiple reads/connects at a time anyway, so these * handles can be pre-initialized. */ @@ -268,10 +268,10 @@ static void tcp_pinger_new(int vectored_writes) { &pinger->stream.tcp, (const struct sockaddr*) &server_addr, pinger_on_connect); - ASSERT_OK(r); + ASSERT_EQ(0, r); /* Synchronous connect callbacks are not allowed. */ - ASSERT_OK(pinger_on_connect_count); + ASSERT_EQ(pinger_on_connect_count, 0); } @@ -289,7 +289,7 @@ static void pipe_pinger_new(int vectored_writes) { /* Try to connect to the server and do NUM_PINGS ping-pongs. */ r = uv_pipe_init(uv_default_loop(), &pinger->stream.pipe, 0); pinger->stream.pipe.data = pinger; - ASSERT_OK(r); + ASSERT_EQ(0, r); /* We are never doing multiple reads/connects at a time anyway, so these * handles can be pre-initialized. */ @@ -297,7 +297,7 @@ static void pipe_pinger_new(int vectored_writes) { pinger_on_connect); /* Synchronous connect callbacks are not allowed. */ - ASSERT_OK(pinger_on_connect_count); + ASSERT_EQ(pinger_on_connect_count, 0); } @@ -315,31 +315,31 @@ static void socketpair_pinger_new(int vectored_writes) { /* Try to make a socketpair and do NUM_PINGS ping-pongs. */ (void)uv_default_loop(); /* ensure WSAStartup has been performed */ - ASSERT_OK(uv_socketpair(SOCK_STREAM, 0, fds, UV_NONBLOCK_PIPE, UV_NONBLOCK_PIPE)); + ASSERT_EQ(0, uv_socketpair(SOCK_STREAM, 0, fds, UV_NONBLOCK_PIPE, UV_NONBLOCK_PIPE)); #ifndef _WIN32 /* On Windows, this is actually a UV_TCP, but libuv doesn't detect that. */ ASSERT_EQ(uv_guess_handle((uv_file) fds[0]), UV_NAMED_PIPE); ASSERT_EQ(uv_guess_handle((uv_file) fds[1]), UV_NAMED_PIPE); #endif - ASSERT_OK(uv_tcp_init(uv_default_loop(), &pinger->stream.tcp)); + ASSERT_EQ(0, uv_tcp_init(uv_default_loop(), &pinger->stream.tcp)); pinger->stream.pipe.data = pinger; - ASSERT_OK(uv_tcp_open(&pinger->stream.tcp, fds[1])); + ASSERT_EQ(0, uv_tcp_open(&pinger->stream.tcp, fds[1])); ponger = malloc(sizeof(*ponger)); ASSERT_NOT_NULL(ponger); ponger->data = NULL; - ASSERT_OK(uv_tcp_init(uv_default_loop(), ponger)); - ASSERT_OK(uv_tcp_open(ponger, fds[0])); + ASSERT_EQ(0, uv_tcp_init(uv_default_loop(), ponger)); + ASSERT_EQ(0, uv_tcp_open(ponger, fds[0])); pinger_write_ping(pinger); - ASSERT_OK(uv_read_start((uv_stream_t*) &pinger->stream.tcp, - alloc_cb, - pinger_read_cb)); - ASSERT_OK(uv_read_start((uv_stream_t*) ponger, - alloc_cb, - ponger_read_cb)); + ASSERT_EQ(0, uv_read_start((uv_stream_t*) &pinger->stream.tcp, + alloc_cb, + pinger_read_cb)); + ASSERT_EQ(0, uv_read_start((uv_stream_t*) ponger, + alloc_cb, + ponger_read_cb)); } @@ -349,14 +349,14 @@ static void pipe2_pinger_new(int vectored_writes) { uv_pipe_t* ponger; /* Try to make a pipe and do NUM_PINGS pings. */ - ASSERT_OK(uv_pipe(fds, UV_NONBLOCK_PIPE, UV_NONBLOCK_PIPE)); + ASSERT_EQ(0, uv_pipe(fds, UV_NONBLOCK_PIPE, UV_NONBLOCK_PIPE)); ASSERT_EQ(uv_guess_handle(fds[0]), UV_NAMED_PIPE); ASSERT_EQ(uv_guess_handle(fds[1]), UV_NAMED_PIPE); ponger = malloc(sizeof(*ponger)); ASSERT_NOT_NULL(ponger); - ASSERT_OK(uv_pipe_init(uv_default_loop(), ponger, 0)); - ASSERT_OK(uv_pipe_open(ponger, fds[0])); + ASSERT_EQ(0, uv_pipe_init(uv_default_loop(), ponger, 0)); + ASSERT_EQ(0, uv_pipe_open(ponger, fds[0])); pinger = malloc(sizeof(*pinger)); ASSERT_NOT_NULL(pinger); @@ -364,21 +364,21 @@ static void pipe2_pinger_new(int vectored_writes) { pinger->state = 0; pinger->pongs = 0; pinger->pong = PING; - ASSERT_OK(uv_pipe_init(uv_default_loop(), &pinger->stream.pipe, 0)); - ASSERT_OK(uv_pipe_open(&pinger->stream.pipe, fds[1])); + ASSERT_EQ(0, uv_pipe_init(uv_default_loop(), &pinger->stream.pipe, 0)); + ASSERT_EQ(0, uv_pipe_open(&pinger->stream.pipe, fds[1])); pinger->stream.pipe.data = pinger; /* record for close_cb */ ponger->data = pinger; /* record for read_cb */ pinger_write_ping(pinger); - ASSERT_OK(uv_read_start((uv_stream_t*) ponger, alloc_cb, pinger_read_cb)); + ASSERT_EQ(0, uv_read_start((uv_stream_t*) ponger, alloc_cb, pinger_read_cb)); } static int run_ping_pong_test(void) { uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_EQ(1, completed_pingers); + ASSERT_EQ(completed_pingers, 1); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-pipe-bind-error.c b/test/test-pipe-bind-error.c index 412f23a..aacde45 100644 --- a/test/test-pipe-bind-error.c +++ b/test/test-pipe-bind-error.c @@ -33,7 +33,6 @@ static int close_cb_called = 0; -static int connect_cb_called = 0; static void close_cb(uv_handle_t* handle) { @@ -47,28 +46,28 @@ TEST_IMPL(pipe_bind_error_addrinuse) { int r; r = uv_pipe_init(uv_default_loop(), &server1, 0); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_pipe_bind(&server1, TEST_PIPENAME); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_pipe_init(uv_default_loop(), &server2, 0); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_pipe_bind(&server2, TEST_PIPENAME); - ASSERT_EQ(r, UV_EADDRINUSE); + ASSERT(r == UV_EADDRINUSE); r = uv_listen((uv_stream_t*)&server1, SOMAXCONN, NULL); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_listen((uv_stream_t*)&server2, SOMAXCONN, NULL); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); uv_close((uv_handle_t*)&server1, close_cb); uv_close((uv_handle_t*)&server2, close_cb); uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_EQ(2, close_cb_called); + ASSERT(close_cb_called == 2); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -78,18 +77,18 @@ TEST_IMPL(pipe_bind_error_addrnotavail) { int r; r = uv_pipe_init(uv_default_loop(), &server, 0); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_pipe_bind(&server, BAD_PIPENAME); - ASSERT_EQ(r, UV_EACCES); + ASSERT(r == UV_EACCES); uv_close((uv_handle_t*)&server, close_cb); uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_EQ(1, close_cb_called); + ASSERT(close_cb_called == 1); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -99,19 +98,19 @@ TEST_IMPL(pipe_bind_error_inval) { int r; r = uv_pipe_init(uv_default_loop(), &server, 0); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_pipe_bind(&server, TEST_PIPENAME); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_pipe_bind(&server, TEST_PIPENAME_2); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); uv_close((uv_handle_t*)&server, close_cb); uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_EQ(1, close_cb_called); + ASSERT(close_cb_called == 1); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -124,76 +123,33 @@ TEST_IMPL(pipe_listen_without_bind) { int r; r = uv_pipe_init(uv_default_loop(), &server, 0); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_listen((uv_stream_t*)&server, SOMAXCONN, NULL); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); uv_close((uv_handle_t*)&server, close_cb); uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_EQ(1, close_cb_called); + ASSERT(close_cb_called == 1); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } TEST_IMPL(pipe_bind_or_listen_error_after_close) { uv_pipe_t server; - ASSERT_OK(uv_pipe_init(uv_default_loop(), &server, 0)); + ASSERT_EQ(uv_pipe_init(uv_default_loop(), &server, 0), 0); uv_close((uv_handle_t*) &server, NULL); ASSERT_EQ(uv_pipe_bind(&server, TEST_PIPENAME), UV_EINVAL); ASSERT_EQ(uv_listen((uv_stream_t*) &server, SOMAXCONN, NULL), UV_EINVAL); - ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT)); + ASSERT_EQ(uv_run(uv_default_loop(), UV_RUN_DEFAULT), 0); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } - - -static void connect_overlong_cb(uv_connect_t* connect_req, int status) { - ASSERT_EQ(status, UV_EINVAL); - connect_cb_called++; - uv_close((uv_handle_t*) connect_req->handle, close_cb); -} - - -TEST_IMPL(pipe_overlong_path) { - uv_pipe_t pipe; - uv_connect_t req; - - ASSERT_OK(uv_pipe_init(uv_default_loop(), &pipe, 0)); - -#ifndef _WIN32 - char path[512]; - memset(path, '@', sizeof(path)); - ASSERT_EQ(UV_EINVAL, - uv_pipe_bind2(&pipe, path, sizeof(path), UV_PIPE_NO_TRUNCATE)); - ASSERT_EQ(UV_EINVAL, - uv_pipe_connect2(&req, - &pipe, - path, - sizeof(path), - UV_PIPE_NO_TRUNCATE, - (uv_connect_cb) abort)); - ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT)); -#endif - - ASSERT_EQ(UV_EINVAL, uv_pipe_bind(&pipe, "")); - uv_pipe_connect(&req, - &pipe, - "", - (uv_connect_cb) connect_overlong_cb); - ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT)); - ASSERT_EQ(1, connect_cb_called); - ASSERT_EQ(1, close_cb_called); - - MAKE_VALGRIND_HAPPY(uv_default_loop()); - return 0; - -} diff --git a/test/test-pipe-close-stdout-read-stdin.c b/test/test-pipe-close-stdout-read-stdin.c index 51bbf0f..126be2c 100644 --- a/test/test-pipe-close-stdout-read-stdin.c +++ b/test/test-pipe-close-stdout-read-stdin.c @@ -26,10 +26,6 @@ #include #include -#ifdef __APPLE__ -#include -#endif - #include "uv.h" #include "task.h" @@ -61,15 +57,9 @@ TEST_IMPL(pipe_close_stdout_read_stdin) { uv_pipe_t stdin_pipe; r = pipe(fd); - ASSERT_OK(r); - -#if defined(__APPLE__) && (TARGET_OS_TV || TARGET_OS_WATCH) - pid = -1; -#else - pid = fork(); -#endif + ASSERT(r == 0); - if (pid == 0) { + if ((pid = fork()) == 0) { /* * Make the read side of the pipe our stdin. * The write side will be closed by the parent process. @@ -80,24 +70,24 @@ TEST_IMPL(pipe_close_stdout_read_stdin) { ASSERT(-1 <= r && r <= 1); close(0); r = dup(fd[0]); - ASSERT_NE(r, -1); + ASSERT(r != -1); /* Create a stream that reads from the pipe. */ r = uv_pipe_init(uv_default_loop(), (uv_pipe_t *)&stdin_pipe, 0); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_pipe_open((uv_pipe_t *)&stdin_pipe, 0); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_read_start((uv_stream_t *)&stdin_pipe, alloc_buffer, read_stdin); - ASSERT_OK(r); + ASSERT(r == 0); /* * Because the other end of the pipe was closed, there should * be no event left to process after one run of the event loop. * Otherwise, it means that events were not processed correctly. */ - ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_NOWAIT)); + ASSERT(uv_run(uv_default_loop(), UV_RUN_NOWAIT) == 0); } else { /* * Close both ends of the pipe so that the child @@ -111,7 +101,7 @@ TEST_IMPL(pipe_close_stdout_read_stdin) { ASSERT(WIFEXITED(status) && WEXITSTATUS(status) == 0); } - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-pipe-connect-error.c b/test/test-pipe-connect-error.c index ee6e077..0f1e2b1 100644 --- a/test/test-pipe-connect-error.c +++ b/test/test-pipe-connect-error.c @@ -43,17 +43,15 @@ static void close_cb(uv_handle_t* handle) { static void connect_cb(uv_connect_t* connect_req, int status) { - ASSERT_EQ(status, UV_ENOENT); - uv_close((uv_handle_t*) connect_req->handle, close_cb); + ASSERT(status == UV_ENOENT); + uv_close((uv_handle_t*)connect_req->handle, close_cb); connect_cb_called++; } static void connect_cb_file(uv_connect_t* connect_req, int status) { - if (status != UV_ENOTSOCK) - if (status != UV_EACCES) - ASSERT_EQ(status, UV_ECONNREFUSED); - uv_close((uv_handle_t*) connect_req->handle, close_cb); + ASSERT(status == UV_ENOTSOCK || status == UV_ECONNREFUSED); + uv_close((uv_handle_t*)connect_req->handle, close_cb); connect_cb_called++; } @@ -64,15 +62,15 @@ TEST_IMPL(pipe_connect_bad_name) { int r; r = uv_pipe_init(uv_default_loop(), &client, 0); - ASSERT_OK(r); + ASSERT(r == 0); uv_pipe_connect(&req, &client, BAD_PIPENAME, connect_cb); uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_EQ(1, close_cb_called); - ASSERT_EQ(1, connect_cb_called); + ASSERT(close_cb_called == 1); + ASSERT(connect_cb_called == 1); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -84,14 +82,14 @@ TEST_IMPL(pipe_connect_to_file) { int r; r = uv_pipe_init(uv_default_loop(), &client, 0); - ASSERT_OK(r); + ASSERT(r == 0); uv_pipe_connect(&req, &client, path, connect_cb_file); uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_EQ(1, close_cb_called); - ASSERT_EQ(1, connect_cb_called); + ASSERT(close_cb_called == 1); + ASSERT(connect_cb_called == 1); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-pipe-connect-multiple.c b/test/test-pipe-connect-multiple.c index 69a09ec..0a60d4a 100644 --- a/test/test-pipe-connect-multiple.c +++ b/test/test-pipe-connect-multiple.c @@ -29,7 +29,7 @@ static int connection_cb_called = 0; static int connect_cb_called = 0; -#define NUM_CLIENTS 10 +#define NUM_CLIENTS 4 typedef struct { uv_pipe_t pipe_handle; @@ -44,14 +44,14 @@ static uv_pipe_t connections[NUM_CLIENTS]; static void connection_cb(uv_stream_t* server, int status) { int r; uv_pipe_t* conn; - ASSERT_OK(status); + ASSERT(status == 0); conn = &connections[connection_cb_called]; r = uv_pipe_init(server->loop, conn, 0); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_accept(server, (uv_stream_t*)conn); - ASSERT_OK(r); + ASSERT(r == 0); if (++connection_cb_called == NUM_CLIENTS && connect_cb_called == NUM_CLIENTS) { @@ -61,7 +61,7 @@ static void connection_cb(uv_stream_t* server, int status) { static void connect_cb(uv_connect_t* connect_req, int status) { - ASSERT_OK(status); + ASSERT(status == 0); if (++connect_cb_called == NUM_CLIENTS && connection_cb_called == NUM_CLIENTS) { uv_stop(connect_req->handle->loop); @@ -80,17 +80,17 @@ TEST_IMPL(pipe_connect_multiple) { loop = uv_default_loop(); r = uv_pipe_init(loop, &server_handle, 0); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_pipe_bind(&server_handle, TEST_PIPENAME); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_listen((uv_stream_t*)&server_handle, 128, connection_cb); - ASSERT_OK(r); + ASSERT(r == 0); for (i = 0; i < NUM_CLIENTS; i++) { r = uv_pipe_init(loop, &clients[i].pipe_handle, 0); - ASSERT_OK(r); + ASSERT(r == 0); uv_pipe_connect(&clients[i].conn_req, &clients[i].pipe_handle, TEST_PIPENAME, @@ -99,80 +99,9 @@ TEST_IMPL(pipe_connect_multiple) { uv_run(loop, UV_RUN_DEFAULT); - ASSERT_EQ(connection_cb_called, NUM_CLIENTS); - ASSERT_EQ(connect_cb_called, NUM_CLIENTS); + ASSERT(connection_cb_called == NUM_CLIENTS); + ASSERT(connect_cb_called == NUM_CLIENTS); - MAKE_VALGRIND_HAPPY(loop); - return 0; -} - - -static void connection_cb2(uv_stream_t* server, int status) { - int r; - uv_pipe_t* conn; - ASSERT_OK(status); - - conn = &connections[connection_cb_called]; - r = uv_pipe_init(server->loop, conn, 0); - ASSERT_OK(r); - - r = uv_accept(server, (uv_stream_t*)conn); - ASSERT_OK(r); - - uv_close((uv_handle_t*)conn, NULL); - if (++connection_cb_called == NUM_CLIENTS && - connect_cb_called == NUM_CLIENTS) { - uv_close((uv_handle_t*)&server_handle, NULL); - } -} - -static void connect_cb2(uv_connect_t* connect_req, int status) { - ASSERT_EQ(status, UV_ECANCELED); - if (++connect_cb_called == NUM_CLIENTS && - connection_cb_called == NUM_CLIENTS) { - uv_close((uv_handle_t*)&server_handle, NULL); - } -} - - -TEST_IMPL(pipe_connect_close_multiple) { -#if defined(NO_SELF_CONNECT) - RETURN_SKIP(NO_SELF_CONNECT); -#endif - int i; - int r; - uv_loop_t* loop; - - loop = uv_default_loop(); - - r = uv_pipe_init(loop, &server_handle, 0); - ASSERT_OK(r); - - r = uv_pipe_bind(&server_handle, TEST_PIPENAME); - ASSERT_OK(r); - - r = uv_listen((uv_stream_t*)&server_handle, 128, connection_cb2); - ASSERT_OK(r); - - for (i = 0; i < NUM_CLIENTS; i++) { - r = uv_pipe_init(loop, &clients[i].pipe_handle, 0); - ASSERT_OK(r); - uv_pipe_connect(&clients[i].conn_req, - &clients[i].pipe_handle, - TEST_PIPENAME, - connect_cb2); - } - - for (i = 0; i < NUM_CLIENTS; i++) { - uv_close((uv_handle_t*)&clients[i].pipe_handle, NULL); - } - - - uv_run(loop, UV_RUN_DEFAULT); - - ASSERT_EQ(connection_cb_called, NUM_CLIENTS); - ASSERT_EQ(connect_cb_called, NUM_CLIENTS); - - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-pipe-connect-prepare.c b/test/test-pipe-connect-prepare.c index 93d15a4..08b57cb 100644 --- a/test/test-pipe-connect-prepare.c +++ b/test/test-pipe-connect-prepare.c @@ -48,7 +48,7 @@ static void close_cb(uv_handle_t* handle) { static void connect_cb(uv_connect_t* connect_req, int status) { - ASSERT_EQ(status, UV_ENOENT); + ASSERT(status == UV_ENOENT); connect_cb_called++; uv_close((uv_handle_t*)&prepare_handle, close_cb); uv_close((uv_handle_t*)&pipe_handle, close_cb); @@ -56,7 +56,7 @@ static void connect_cb(uv_connect_t* connect_req, int status) { static void prepare_cb(uv_prepare_t* handle) { - ASSERT_PTR_EQ(handle, &prepare_handle); + ASSERT(handle == &prepare_handle); uv_pipe_connect(&conn_req, &pipe_handle, BAD_PIPENAME, connect_cb); } @@ -65,19 +65,19 @@ TEST_IMPL(pipe_connect_on_prepare) { int r; r = uv_pipe_init(uv_default_loop(), &pipe_handle, 0); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_prepare_init(uv_default_loop(), &prepare_handle); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_prepare_start(&prepare_handle, prepare_cb); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_EQ(2, close_cb_called); - ASSERT_EQ(1, connect_cb_called); + ASSERT(close_cb_called == 2); + ASSERT(connect_cb_called == 1); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-pipe-getsockname.c b/test/test-pipe-getsockname.c index d76b6ad..79db8eb 100644 --- a/test/test-pipe-getsockname.c +++ b/test/test-pipe-getsockname.c @@ -25,6 +25,11 @@ #include #include +#if defined(__linux__) + #include + #include +#endif + #ifndef _WIN32 # include /* close */ #else @@ -40,8 +45,8 @@ static int pipe_client_connect_cb_called = 0; static void pipe_close_cb(uv_handle_t* handle) { - ASSERT_NE(handle == (uv_handle_t*) &pipe_client || - handle == (uv_handle_t*) &pipe_server, 0); + ASSERT(handle == (uv_handle_t*) &pipe_client || + handle == (uv_handle_t*) &pipe_server); pipe_close_cb_called++; } @@ -51,21 +56,15 @@ static void pipe_client_connect_cb(uv_connect_t* req, int status) { size_t len; int r; - ASSERT_PTR_EQ(req, &connect_req); - ASSERT_OK(status); + ASSERT(req == &connect_req); + ASSERT(status == 0); len = sizeof buf; r = uv_pipe_getpeername(&pipe_client, buf, &len); - ASSERT_OK(r); + ASSERT(r == 0); - if (*buf == '\0') { /* Linux abstract socket. */ - const char expected[] = "\0" TEST_PIPENAME; - ASSERT_EQ(len, sizeof(expected) - 1); - ASSERT_MEM_EQ(buf, expected, len); - } else { - ASSERT_NE(0, buf[len - 1]); - ASSERT_MEM_EQ(buf, TEST_PIPENAME, len); - } + ASSERT(buf[len - 1] != 0); + ASSERT(memcmp(buf, TEST_PIPENAME, len) == 0); len = sizeof buf; r = uv_pipe_getsockname(&pipe_client, buf, &len); @@ -73,6 +72,7 @@ static void pipe_client_connect_cb(uv_connect_t* req, int status) { pipe_client_connect_cb_called++; + uv_close((uv_handle_t*) &pipe_client, pipe_close_cb); uv_close((uv_handle_t*) &pipe_server, pipe_close_cb); } @@ -82,7 +82,7 @@ static void pipe_server_connection_cb(uv_stream_t* handle, int status) { /* This function *may* be called, depending on whether accept or the * connection callback is called first. */ - ASSERT_OK(status); + ASSERT(status == 0); } @@ -91,72 +91,54 @@ TEST_IMPL(pipe_getsockname) { RETURN_SKIP(NO_SELF_CONNECT); #endif uv_loop_t* loop; - char namebuf[256]; char buf[1024]; - size_t namelen; size_t len; int r; - snprintf(namebuf, sizeof(namebuf), "%s-oob", TEST_PIPENAME); - namelen = sizeof(TEST_PIPENAME) - 1; - loop = uv_default_loop(); ASSERT_NOT_NULL(loop); r = uv_pipe_init(loop, &pipe_server, 0); - ASSERT_OK(r); - - r = uv_pipe_bind2(&pipe_server, "bad\0path", 8, 0); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == 0); len = sizeof buf; r = uv_pipe_getsockname(&pipe_server, buf, &len); - ASSERT_EQ(r, UV_EBADF); + ASSERT(r == UV_EBADF); len = sizeof buf; r = uv_pipe_getpeername(&pipe_server, buf, &len); - ASSERT_EQ(r, UV_EBADF); - - r = uv_pipe_bind2(&pipe_server, namebuf, namelen, 0); - ASSERT_OK(r); + ASSERT(r == UV_EBADF); -#ifndef _WIN32 - ASSERT_STR_EQ(pipe_server.pipe_fname, TEST_PIPENAME); -#endif + r = uv_pipe_bind(&pipe_server, TEST_PIPENAME); + ASSERT(r == 0); len = sizeof buf; r = uv_pipe_getsockname(&pipe_server, buf, &len); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_NE(0, buf[len - 1]); - ASSERT_EQ(buf[len], '\0'); - ASSERT_OK(memcmp(buf, TEST_PIPENAME, len)); + ASSERT(buf[len - 1] != 0); + ASSERT(buf[len] == '\0'); + ASSERT(memcmp(buf, TEST_PIPENAME, len) == 0); len = sizeof buf; r = uv_pipe_getpeername(&pipe_server, buf, &len); - ASSERT_EQ(r, UV_ENOTCONN); + ASSERT(r == UV_ENOTCONN); r = uv_listen((uv_stream_t*) &pipe_server, 0, pipe_server_connection_cb); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_pipe_init(loop, &pipe_client, 0); - ASSERT_OK(r); + ASSERT(r == 0); len = sizeof buf; r = uv_pipe_getsockname(&pipe_client, buf, &len); - ASSERT_EQ(r, UV_EBADF); + ASSERT(r == UV_EBADF); len = sizeof buf; r = uv_pipe_getpeername(&pipe_client, buf, &len); - ASSERT_EQ(r, UV_EBADF); + ASSERT(r == UV_EBADF); - r = uv_pipe_connect2(&connect_req, - &pipe_client, - namebuf, - namelen, - 0, - pipe_client_connect_cb); - ASSERT_OK(r); + uv_pipe_connect(&connect_req, &pipe_client, TEST_PIPENAME, pipe_client_connect_cb); len = sizeof buf; r = uv_pipe_getsockname(&pipe_client, buf, &len); @@ -164,66 +146,64 @@ TEST_IMPL(pipe_getsockname) { len = sizeof buf; r = uv_pipe_getpeername(&pipe_client, buf, &len); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_NE(0, buf[len - 1]); - ASSERT_OK(memcmp(buf, TEST_PIPENAME, len)); + ASSERT(buf[len - 1] != 0); + ASSERT(memcmp(buf, TEST_PIPENAME, len) == 0); r = uv_run(loop, UV_RUN_DEFAULT); - ASSERT_OK(r); - ASSERT_EQ(1, pipe_client_connect_cb_called); - ASSERT_EQ(2, pipe_close_cb_called); + ASSERT(r == 0); + ASSERT(pipe_client_connect_cb_called == 1); + ASSERT(pipe_close_cb_called == 2); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } TEST_IMPL(pipe_getsockname_abstract) { - /* TODO(bnoordhuis) Use unique name, susceptible to concurrent test runs. */ - static const char name[] = "\0" TEST_PIPENAME; #if defined(__linux__) - char buf[256]; - size_t buflen; - - buflen = sizeof(buf); - memset(buf, 0, sizeof(buf)); - ASSERT_OK(uv_pipe_init(uv_default_loop(), &pipe_server, 0)); - ASSERT_OK(uv_pipe_bind2(&pipe_server, name, sizeof(name) - 1, 0)); - ASSERT_OK(uv_pipe_getsockname(&pipe_server, buf, &buflen)); - ASSERT_UINT64_EQ(sizeof(name) - 1, buflen); - ASSERT_MEM_EQ(name, buf, buflen); - ASSERT_OK(uv_listen((uv_stream_t*) &pipe_server, - 0, - pipe_server_connection_cb)); - ASSERT_OK(uv_pipe_init(uv_default_loop(), &pipe_client, 0)); - ASSERT_OK(uv_pipe_connect2(&connect_req, - &pipe_client, - name, - sizeof(name) - 1, - 0, - pipe_client_connect_cb)); - ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT)); - ASSERT_EQ(1, pipe_client_connect_cb_called); - ASSERT_EQ(2, pipe_close_cb_called); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + char buf[1024]; + size_t len; + int r; + int sock; + struct sockaddr_un sun; + socklen_t sun_len; + char abstract_pipe[] = "\0test-pipe"; + + sock = socket(AF_UNIX, SOCK_STREAM, 0); + ASSERT(sock != -1); + + sun_len = sizeof sun; + memset(&sun, 0, sun_len); + sun.sun_family = AF_UNIX; + memcpy(sun.sun_path, abstract_pipe, sizeof abstract_pipe); + + r = bind(sock, (struct sockaddr*)&sun, sun_len); + ASSERT(r == 0); + + r = uv_pipe_init(uv_default_loop(), &pipe_server, 0); + ASSERT(r == 0); + r = uv_pipe_open(&pipe_server, sock); + ASSERT(r == 0); + + len = sizeof buf; + r = uv_pipe_getsockname(&pipe_server, buf, &len); + ASSERT(r == 0); + + ASSERT(memcmp(buf, abstract_pipe, sizeof abstract_pipe) == 0); + + uv_close((uv_handle_t*)&pipe_server, pipe_close_cb); + + uv_run(uv_default_loop(), UV_RUN_DEFAULT); + + close(sock); + + ASSERT(pipe_close_cb_called == 1); + MAKE_VALGRIND_HAPPY(); return 0; #else - /* On other platforms it should simply fail with UV_EINVAL. */ - ASSERT_OK(uv_pipe_init(uv_default_loop(), &pipe_server, 0)); - ASSERT_EQ(UV_EINVAL, uv_pipe_bind2(&pipe_server, name, sizeof(name), 0)); - ASSERT_OK(uv_pipe_init(uv_default_loop(), &pipe_client, 0)); - uv_close((uv_handle_t*) &pipe_server, pipe_close_cb); - ASSERT_EQ(UV_EINVAL, uv_pipe_connect2(&connect_req, - &pipe_client, - name, - sizeof(name), - 0, - (uv_connect_cb) abort)); - uv_close((uv_handle_t*) &pipe_client, pipe_close_cb); - ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT)); - ASSERT_EQ(2, pipe_close_cb_called); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; #endif } @@ -237,54 +217,54 @@ TEST_IMPL(pipe_getsockname_blocking) { int r; r = CreatePipe(&readh, &writeh, NULL, 65536); - ASSERT(r); + ASSERT(r != 0); r = uv_pipe_init(uv_default_loop(), &pipe_client, 0); - ASSERT_OK(r); + ASSERT(r == 0); readfd = _open_osfhandle((intptr_t)readh, _O_RDONLY); - ASSERT_NE(r, -1); + ASSERT(r != -1); r = uv_pipe_open(&pipe_client, readfd); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_read_start((uv_stream_t*) &pipe_client, (uv_alloc_cb) abort, (uv_read_cb) abort); - ASSERT_OK(r); + ASSERT(r == 0); Sleep(100); r = uv_read_stop((uv_stream_t*)&pipe_client); - ASSERT_OK(r); + ASSERT(r == 0); len1 = sizeof buf1; r = uv_pipe_getsockname(&pipe_client, buf1, &len1); - ASSERT_OK(r); - ASSERT_OK(len1); /* It's an annonymous pipe. */ + ASSERT(r == 0); + ASSERT(len1 == 0); /* It's an annonymous pipe. */ r = uv_read_start((uv_stream_t*)&pipe_client, (uv_alloc_cb) abort, (uv_read_cb) abort); - ASSERT_OK(r); + ASSERT(r == 0); Sleep(100); len2 = sizeof buf2; r = uv_pipe_getsockname(&pipe_client, buf2, &len2); - ASSERT_OK(r); - ASSERT_OK(len2); /* It's an annonymous pipe. */ + ASSERT(r == 0); + ASSERT(len2 == 0); /* It's an annonymous pipe. */ r = uv_read_stop((uv_stream_t*)&pipe_client); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_EQ(len1, len2); - ASSERT_OK(memcmp(buf1, buf2, len1)); + ASSERT(len1 == len2); + ASSERT(memcmp(buf1, buf2, len1) == 0); pipe_close_cb_called = 0; uv_close((uv_handle_t*)&pipe_client, pipe_close_cb); uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_EQ(1, pipe_close_cb_called); + ASSERT(pipe_close_cb_called == 1); CloseHandle(writeh); #endif - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-pipe-pending-instances.c b/test/test-pipe-pending-instances.c index 570ecd6..b6ff911 100644 --- a/test/test-pipe-pending-instances.c +++ b/test/test-pipe-pending-instances.c @@ -37,23 +37,23 @@ TEST_IMPL(pipe_pending_instances) { loop = uv_default_loop(); r = uv_pipe_init(loop, &pipe_handle, 0); - ASSERT_OK(r); + ASSERT(r == 0); uv_pipe_pending_instances(&pipe_handle, 8); r = uv_pipe_bind(&pipe_handle, TEST_PIPENAME); - ASSERT_OK(r); + ASSERT(r == 0); uv_pipe_pending_instances(&pipe_handle, 16); r = uv_listen((uv_stream_t*)&pipe_handle, 128, connection_cb); - ASSERT_OK(r); + ASSERT(r == 0); uv_close((uv_handle_t*)&pipe_handle, NULL); r = uv_run(loop, UV_RUN_DEFAULT); - ASSERT_OK(r); + ASSERT(r == 0); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-pipe-sendmsg.c b/test/test-pipe-sendmsg.c index 3958b05..3bf427f 100644 --- a/test/test-pipe-sendmsg.c +++ b/test/test-pipe-sendmsg.c @@ -45,12 +45,12 @@ static void set_nonblocking(uv_os_sock_t sock) { #ifdef _WIN32 unsigned long on = 1; r = ioctlsocket(sock, FIONBIO, &on); - ASSERT_OK(r); + ASSERT(r == 0); #else int flags = fcntl(sock, F_GETFL, 0); - ASSERT_GE(flags, 0); + ASSERT(flags >= 0); r = fcntl(sock, F_SETFL, flags | O_NONBLOCK); - ASSERT_GE(r, 0); + ASSERT(r >= 0); #endif } @@ -79,22 +79,22 @@ static void read_cb(uv_stream_t* handle, unsigned int i; p = (uv_pipe_t*) handle; - ASSERT_GE(nread, 0); + ASSERT(nread >= 0); while (uv_pipe_pending_count(p) != 0) { pending = uv_pipe_pending_type(p); - ASSERT_EQ(pending, UV_NAMED_PIPE); + ASSERT(pending == UV_NAMED_PIPE); - ASSERT_LT(incoming_count, ARRAY_SIZE(incoming)); + ASSERT(incoming_count < ARRAY_SIZE(incoming)); inc = &incoming[incoming_count++]; - ASSERT_OK(uv_pipe_init(p->loop, inc, 0)); - ASSERT_OK(uv_accept(handle, (uv_stream_t*) inc)); + ASSERT(0 == uv_pipe_init(p->loop, inc, 0)); + ASSERT(0 == uv_accept(handle, (uv_stream_t*) inc)); } if (incoming_count != ARRAY_SIZE(incoming)) return; - ASSERT_OK(uv_read_stop((uv_stream_t*) p)); + ASSERT(0 == uv_read_stop((uv_stream_t*) p)); uv_close((uv_handle_t*) p, close_cb); for (i = 0; i < ARRAY_SIZE(incoming); i++) uv_close((uv_handle_t*) &incoming[i], close_cb); @@ -115,12 +115,12 @@ TEST_IMPL(pipe_sendmsg) { unsigned int i; uv_buf_t buf; - ASSERT_OK(socketpair(AF_UNIX, SOCK_STREAM, 0, fds)); + ASSERT(0 == socketpair(AF_UNIX, SOCK_STREAM, 0, fds)); for (i = 0; i < ARRAY_SIZE(send_fds); i += 2) - ASSERT_OK(socketpair(AF_UNIX, SOCK_STREAM, 0, send_fds + i)); - ASSERT_EQ(i, ARRAY_SIZE(send_fds)); - ASSERT_OK(uv_pipe_init(uv_default_loop(), &p, 1)); - ASSERT_OK(uv_pipe_open(&p, fds[1])); + ASSERT(0 == socketpair(AF_UNIX, SOCK_STREAM, 0, send_fds + i)); + ASSERT(i == ARRAY_SIZE(send_fds)); + ASSERT(0 == uv_pipe_init(uv_default_loop(), &p, 1)); + ASSERT(0 == uv_pipe_open(&p, fds[1])); buf = uv_buf_init("X", 1); memset(&msg, 0, sizeof(msg)); @@ -130,7 +130,7 @@ TEST_IMPL(pipe_sendmsg) { msg.msg_control = (void*) scratch; msg.msg_controllen = CMSG_LEN(sizeof(send_fds)); - ASSERT_GE(sizeof(scratch), msg.msg_controllen); + ASSERT(sizeof(scratch) >= msg.msg_controllen); cmsg = CMSG_FIRSTHDR(&msg); cmsg->cmsg_level = SOL_SOCKET; @@ -146,26 +146,26 @@ TEST_IMPL(pipe_sendmsg) { } set_nonblocking(fds[1]); - ASSERT_OK(uv_read_start((uv_stream_t*) &p, alloc_cb, read_cb)); + ASSERT(0 == uv_read_start((uv_stream_t*) &p, alloc_cb, read_cb)); do r = sendmsg(fds[0], &msg, 0); while (r == -1 && errno == EINTR); - ASSERT_EQ(1, r); + ASSERT(r == 1); uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_EQ(ARRAY_SIZE(incoming), incoming_count); - ASSERT_EQ(ARRAY_SIZE(incoming) + 1, close_called); + ASSERT(ARRAY_SIZE(incoming) == incoming_count); + ASSERT(ARRAY_SIZE(incoming) + 1 == close_called); close(fds[0]); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } #else /* !_WIN32 */ TEST_IMPL(pipe_sendmsg) { - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-pipe-server-close.c b/test/test-pipe-server-close.c index ad7d792..25305b3 100644 --- a/test/test-pipe-server-close.c +++ b/test/test-pipe-server-close.c @@ -35,15 +35,15 @@ static int pipe_client_connect_cb_called = 0; static void pipe_close_cb(uv_handle_t* handle) { - ASSERT_NE(handle == (uv_handle_t*) &pipe_client || - handle == (uv_handle_t*) &pipe_server, 0); + ASSERT(handle == (uv_handle_t*) &pipe_client || + handle == (uv_handle_t*) &pipe_server); pipe_close_cb_called++; } static void pipe_client_connect_cb(uv_connect_t* req, int status) { - ASSERT_PTR_EQ(req, &connect_req); - ASSERT_OK(status); + ASSERT(req == &connect_req); + ASSERT(status == 0); pipe_client_connect_cb_called++; @@ -56,7 +56,7 @@ static void pipe_server_connection_cb(uv_stream_t* handle, int status) { /* This function *may* be called, depending on whether accept or the * connection callback is called first. */ - ASSERT_OK(status); + ASSERT(status == 0); } @@ -71,24 +71,24 @@ TEST_IMPL(pipe_server_close) { ASSERT_NOT_NULL(loop); r = uv_pipe_init(loop, &pipe_server, 0); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_pipe_bind(&pipe_server, TEST_PIPENAME); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_listen((uv_stream_t*) &pipe_server, 0, pipe_server_connection_cb); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_pipe_init(loop, &pipe_client, 0); - ASSERT_OK(r); + ASSERT(r == 0); uv_pipe_connect(&connect_req, &pipe_client, TEST_PIPENAME, pipe_client_connect_cb); r = uv_run(loop, UV_RUN_DEFAULT); - ASSERT_OK(r); - ASSERT_EQ(1, pipe_client_connect_cb_called); - ASSERT_EQ(2, pipe_close_cb_called); + ASSERT(r == 0); + ASSERT(pipe_client_connect_cb_called == 1); + ASSERT(pipe_close_cb_called == 2); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-pipe-set-fchmod.c b/test/test-pipe-set-fchmod.c index 9563e4f..91e4766 100644 --- a/test/test-pipe-set-fchmod.c +++ b/test/test-pipe-set-fchmod.c @@ -22,7 +22,6 @@ #include "uv.h" #include "task.h" -#include TEST_IMPL(pipe_set_chmod) { uv_pipe_t pipe_handle; @@ -35,29 +34,28 @@ TEST_IMPL(pipe_set_chmod) { loop = uv_default_loop(); r = uv_pipe_init(loop, &pipe_handle, 0); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_pipe_bind(&pipe_handle, TEST_PIPENAME); - ASSERT_OK(r); + ASSERT(r == 0); /* No easy way to test if this works, we will only make sure that the call is * successful. */ r = uv_pipe_chmod(&pipe_handle, UV_READABLE); if (r == UV_EPERM) { - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); RETURN_SKIP("Insufficient privileges to alter pipe fmode"); } - ASSERT_OK(r); + ASSERT(r == 0); #ifndef _WIN32 - memset(&stat_buf, 0, sizeof(stat_buf)); - ASSERT_OK(stat(TEST_PIPENAME, &stat_buf)); + stat(TEST_PIPENAME, &stat_buf); ASSERT(stat_buf.st_mode & S_IRUSR); ASSERT(stat_buf.st_mode & S_IRGRP); ASSERT(stat_buf.st_mode & S_IROTH); #endif r = uv_pipe_chmod(&pipe_handle, UV_WRITABLE); - ASSERT_OK(r); + ASSERT(r == 0); #ifndef _WIN32 stat(TEST_PIPENAME, &stat_buf); ASSERT(stat_buf.st_mode & S_IWUSR); @@ -66,7 +64,7 @@ TEST_IMPL(pipe_set_chmod) { #endif r = uv_pipe_chmod(&pipe_handle, UV_WRITABLE | UV_READABLE); - ASSERT_OK(r); + ASSERT(r == 0); #ifndef _WIN32 stat(TEST_PIPENAME, &stat_buf); ASSERT(stat_buf.st_mode & S_IRUSR); @@ -78,15 +76,15 @@ TEST_IMPL(pipe_set_chmod) { #endif r = uv_pipe_chmod(NULL, UV_WRITABLE | UV_READABLE); - ASSERT_EQ(r, UV_EBADF); + ASSERT(r == UV_EBADF); r = uv_pipe_chmod(&pipe_handle, 12345678); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); uv_close((uv_handle_t*)&pipe_handle, NULL); r = uv_pipe_chmod(&pipe_handle, UV_WRITABLE | UV_READABLE); - ASSERT_EQ(r, UV_EBADF); + ASSERT(r == UV_EBADF); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-pipe-set-non-blocking.c b/test/test-pipe-set-non-blocking.c index bf1c284..c780460 100644 --- a/test/test-pipe-set-non-blocking.c +++ b/test/test-pipe-set-non-blocking.c @@ -46,13 +46,13 @@ static void thread_main(void* arg) { uv_fs_req_cleanup(&req); } while (n > 0 || (n == -1 && uv_errno == UV_EINTR)); - ASSERT_OK(n); + ASSERT(n == 0); } #ifdef _WIN32 static void write_cb(uv_write_t* req, int status) { - ASSERT_OK(status); + ASSERT(status == 0); req->handle = NULL; /* signal completion of write_cb */ } #endif @@ -77,15 +77,15 @@ TEST_IMPL(pipe_set_non_blocking) { uv_write_t write_req; #endif - ASSERT_OK(uv_pipe_init(uv_default_loop(), &pipe_handle, 0)); - ASSERT_OK(uv_pipe(fd, 0, 0)); - ASSERT_OK(uv_pipe_open(&pipe_handle, fd[1])); - ASSERT_OK(uv_stream_set_blocking((uv_stream_t*) &pipe_handle, 1)); + ASSERT(0 == uv_pipe_init(uv_default_loop(), &pipe_handle, 0)); + ASSERT(0 == uv_pipe(fd, 0, 0)); + ASSERT(0 == uv_pipe_open(&pipe_handle, fd[1])); + ASSERT(0 == uv_stream_set_blocking((uv_stream_t*) &pipe_handle, 1)); fd[1] = -1; /* fd[1] is owned by pipe_handle now. */ ctx.fd = fd[0]; - ASSERT_OK(uv_barrier_init(&ctx.barrier, 2)); - ASSERT_OK(uv_thread_create(&thread, thread_main, &ctx)); + ASSERT(0 == uv_barrier_init(&ctx.barrier, 2)); + ASSERT(0 == uv_thread_create(&thread, thread_main, &ctx)); uv_barrier_wait(&ctx.barrier); buf.len = sizeof(data); @@ -99,33 +99,29 @@ TEST_IMPL(pipe_set_non_blocking) { */ n = uv_try_write((uv_stream_t*) &pipe_handle, &buf, 1); #ifdef _WIN32 - ASSERT_EQ(n, UV_EAGAIN); /* E_NOTIMPL */ - ASSERT_OK(uv_write(&write_req, - (uv_stream_t*) &pipe_handle, - &buf, - 1, - write_cb)); + ASSERT(n == UV_EAGAIN); /* E_NOTIMPL */ + ASSERT(0 == uv_write(&write_req, (uv_stream_t*) &pipe_handle, &buf, 1, write_cb)); ASSERT_NOT_NULL(write_req.handle); - ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_ONCE)); + ASSERT(0 == uv_run(uv_default_loop(), UV_RUN_ONCE)); ASSERT_NULL(write_req.handle); /* check for signaled completion of write_cb */ n = buf.len; #endif - ASSERT_EQ(n, sizeof(data)); + ASSERT(n == sizeof(data)); nwritten += n; } uv_close((uv_handle_t*) &pipe_handle, NULL); - ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT)); + ASSERT(0 == uv_run(uv_default_loop(), UV_RUN_DEFAULT)); - ASSERT_OK(uv_thread_join(&thread)); + ASSERT(0 == uv_thread_join(&thread)); #ifdef _WIN32 - ASSERT_OK(_close(fd[0])); /* fd[1] is closed by uv_close(). */ + ASSERT(0 == _close(fd[0])); /* fd[1] is closed by uv_close(). */ #else - ASSERT_OK(close(fd[0])); /* fd[1] is closed by uv_close(). */ + ASSERT(0 == close(fd[0])); /* fd[1] is closed by uv_close(). */ #endif fd[0] = -1; uv_barrier_destroy(&ctx.barrier); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-platform-output.c b/test/test-platform-output.c index f18e097..5827dca 100644 --- a/test/test-platform-output.c +++ b/test/test-platform-output.c @@ -25,6 +25,11 @@ TEST_IMPL(platform_output) { +/* TODO(gengjiawen): Fix test on QEMU. */ +#if defined(__QEMU__) + RETURN_SKIP("Test does not currently work in QEMU"); +#endif + char buffer[512]; size_t rss; size_t size; @@ -35,46 +40,44 @@ TEST_IMPL(platform_output) { uv_cpu_info_t* cpus; uv_interface_address_t* interfaces; uv_passwd_t pwd; - uv_group_t grp; uv_utsname_t uname; unsigned par; - char* const* member; int count; int i; int err; err = uv_get_process_title(buffer, sizeof(buffer)); - ASSERT_OK(err); + ASSERT(err == 0); printf("uv_get_process_title: %s\n", buffer); size = sizeof(buffer); err = uv_cwd(buffer, &size); - ASSERT_OK(err); + ASSERT(err == 0); printf("uv_cwd: %s\n", buffer); err = uv_resident_set_memory(&rss); #if defined(__MSYS__) - ASSERT_EQ(err, UV_ENOSYS); + ASSERT(err == UV_ENOSYS); #else - ASSERT_OK(err); + ASSERT(err == 0); printf("uv_resident_set_memory: %llu\n", (unsigned long long) rss); #endif err = uv_uptime(&uptime); #if defined(__PASE__) - ASSERT_EQ(err, UV_ENOSYS); + ASSERT(err == UV_ENOSYS); #else - ASSERT_OK(err); - ASSERT_GT(uptime, 0); + ASSERT(err == 0); + ASSERT(uptime > 0); printf("uv_uptime: %f\n", uptime); #endif err = uv_getrusage(&rusage); - ASSERT_OK(err); - ASSERT_GE(rusage.ru_utime.tv_sec, 0); - ASSERT_GE(rusage.ru_utime.tv_usec, 0); - ASSERT_GE(rusage.ru_stime.tv_sec, 0); - ASSERT_GE(rusage.ru_stime.tv_usec, 0); + ASSERT(err == 0); + ASSERT(rusage.ru_utime.tv_sec >= 0); + ASSERT(rusage.ru_utime.tv_usec >= 0); + ASSERT(rusage.ru_stime.tv_sec >= 0); + ASSERT(rusage.ru_stime.tv_usec >= 0); printf("uv_getrusage:\n"); printf(" user: %llu sec %llu microsec\n", (unsigned long long) rusage.ru_utime.tv_sec, @@ -92,9 +95,9 @@ TEST_IMPL(platform_output) { err = uv_cpu_info(&cpus, &count); #if defined(__CYGWIN__) || defined(__MSYS__) - ASSERT_EQ(err, UV_ENOSYS); + ASSERT(err == UV_ENOSYS); #else - ASSERT_OK(err); + ASSERT(err == 0); printf("uv_cpu_info:\n"); for (i = 0; i < count; i++) { @@ -113,7 +116,7 @@ TEST_IMPL(platform_output) { uv_free_cpu_info(cpus, count); err = uv_interface_addresses(&interfaces, &count); - ASSERT_OK(err); + ASSERT(err == 0); printf("uv_interface_addresses:\n"); for (i = 0; i < count; i++) { @@ -149,48 +152,25 @@ TEST_IMPL(platform_output) { uv_free_interface_addresses(interfaces, count); err = uv_os_get_passwd(&pwd); - ASSERT_OK(err); - - err = uv_os_get_group(&grp, pwd.gid); -#if defined(_WIN32) - ASSERT_EQ(err, UV_ENOTSUP); - ASSERT_EQ(pwd.uid, (unsigned long) -1); - ASSERT_EQ(pwd.gid, (unsigned long) -1); - (void) member; - grp.groupname = "ENOTSUP"; -#else - ASSERT_OK(err); - ASSERT_EQ(pwd.gid, grp.gid); -#endif + ASSERT(err == 0); printf("uv_os_get_passwd:\n"); printf(" euid: %ld\n", pwd.uid); - printf(" gid: %ld (%s)\n", pwd.gid, grp.groupname); -#if !defined(_WIN32) - printf(" members: ["); - for (member = grp.members; *member != NULL; member++) { - printf(" %s", *member); - } - printf(" ]\n"); -#endif + printf(" gid: %ld\n", pwd.gid); printf(" username: %s\n", pwd.username); - if (pwd.shell != NULL) /* Not set on Windows */ - printf(" shell: %s\n", pwd.shell); + printf(" shell: %s\n", pwd.shell); printf(" home directory: %s\n", pwd.homedir); uv_os_free_passwd(&pwd); -#if !defined(_WIN32) - uv_os_free_group(&grp); -#endif pid = uv_os_getpid(); - ASSERT_GT(pid, 0); + ASSERT(pid > 0); printf("uv_os_getpid: %d\n", (int) pid); ppid = uv_os_getppid(); - ASSERT_GT(ppid, 0); + ASSERT(ppid > 0); printf("uv_os_getppid: %d\n", (int) ppid); err = uv_os_uname(&uname); - ASSERT_OK(err); + ASSERT(err == 0); printf("uv_os_uname:\n"); printf(" sysname: %s\n", uname.sysname); printf(" release: %s\n", uname.release); diff --git a/test/test-poll-close-doesnt-corrupt-stack.c b/test/test-poll-close-doesnt-corrupt-stack.c index 0acb452..1d7e84f 100644 --- a/test/test-poll-close-doesnt-corrupt-stack.c +++ b/test/test-poll-close-doesnt-corrupt-stack.c @@ -59,12 +59,12 @@ static void NO_INLINE close_socket_and_verify_stack(void) { data[i] = MARKER; r = closesocket(sock); - ASSERT_OK(r); + ASSERT(r == 0); uv_sleep(VERIFY_AFTER); for (i = 0; i < ARRAY_SIZE(data); i++) - ASSERT_EQ(data[i], MARKER); + ASSERT(data[i] == MARKER); } #endif @@ -79,36 +79,36 @@ TEST_IMPL(poll_close_doesnt_corrupt_stack) { struct sockaddr_in addr; r = WSAStartup(MAKEWORD(2, 2), &wsa_data); - ASSERT_OK(r); + ASSERT(r == 0); sock = socket(AF_INET, SOCK_STREAM, 0); - ASSERT_NE(sock, INVALID_SOCKET); + ASSERT(sock != INVALID_SOCKET); on = 1; r = ioctlsocket(sock, FIONBIO, &on); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_ip4_addr("127.0.0.1", TEST_PORT, &addr); - ASSERT_OK(r); + ASSERT(r == 0); r = connect(sock, (const struct sockaddr*) &addr, sizeof addr); - ASSERT(r); - ASSERT_EQ(WSAGetLastError(), WSAEWOULDBLOCK); + ASSERT(r != 0); + ASSERT(WSAGetLastError() == WSAEWOULDBLOCK); r = uv_poll_init_socket(uv_default_loop(), &handle, sock); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_poll_start(&handle, UV_READABLE | UV_WRITABLE, poll_cb); - ASSERT_OK(r); + ASSERT(r == 0); uv_close((uv_handle_t*) &handle, close_cb); close_socket_and_verify_stack(); r = uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_EQ(1, close_cb_called); + ASSERT(close_cb_called == 1); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; #endif } diff --git a/test/test-poll-close.c b/test/test-poll-close.c index 5843bf4..2eccddf 100644 --- a/test/test-poll-close.c +++ b/test/test-poll-close.c @@ -50,7 +50,7 @@ TEST_IMPL(poll_close) { { struct WSAData wsa_data; int r = WSAStartup(MAKEWORD(2, 2), &wsa_data); - ASSERT_OK(r); + ASSERT(r == 0); } #endif @@ -66,8 +66,8 @@ TEST_IMPL(poll_close) { uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_EQ(close_cb_called, NUM_SOCKETS); + ASSERT(close_cb_called == NUM_SOCKETS); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-poll-closesocket.c b/test/test-poll-closesocket.c index 01f8f74..1a1c364 100644 --- a/test/test-poll-closesocket.c +++ b/test/test-poll-closesocket.c @@ -39,11 +39,11 @@ static void close_cb(uv_handle_t* h) { static void poll_cb(uv_poll_t* h, int status, int events) { int r; - ASSERT_OK(status); - ASSERT_PTR_EQ(h, &handle); + ASSERT(status == 0); + ASSERT(h == &handle); r = uv_poll_start(&handle, UV_READABLE, poll_cb); - ASSERT_OK(r); + ASSERT(r == 0); closesocket(sock); uv_close((uv_handle_t*) &handle, close_cb); @@ -62,31 +62,31 @@ TEST_IMPL(poll_closesocket) { struct sockaddr_in addr; r = WSAStartup(MAKEWORD(2, 2), &wsa_data); - ASSERT_OK(r); + ASSERT(r == 0); sock = socket(AF_INET, SOCK_STREAM, 0); - ASSERT_NE(sock, INVALID_SOCKET); + ASSERT(sock != INVALID_SOCKET); on = 1; r = ioctlsocket(sock, FIONBIO, &on); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_ip4_addr("127.0.0.1", TEST_PORT, &addr); - ASSERT_OK(r); + ASSERT(r == 0); r = connect(sock, (const struct sockaddr*) &addr, sizeof addr); - ASSERT(r); - ASSERT_EQ(WSAGetLastError(), WSAEWOULDBLOCK); + ASSERT(r != 0); + ASSERT(WSAGetLastError() == WSAEWOULDBLOCK); r = uv_poll_init_socket(uv_default_loop(), &handle, sock); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_poll_start(&handle, UV_WRITABLE, poll_cb); - ASSERT_OK(r); + ASSERT(r == 0); uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_EQ(1, close_cb_called); + ASSERT(close_cb_called == 1); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; #endif } diff --git a/test/test-poll-multiple-handles.c b/test/test-poll-multiple-handles.c index d9c4924..fc2205d 100644 --- a/test/test-poll-multiple-handles.c +++ b/test/test-poll-multiple-handles.c @@ -40,7 +40,7 @@ static void close_cb(uv_handle_t* handle) { static void poll_cb(uv_poll_t* handle, int status, int events) { /* Not a bound socket, linux immediately reports UV_READABLE, other OS do not */ - ASSERT_EQ(events, UV_READABLE); + ASSERT(events == UV_READABLE); } TEST_IMPL(poll_multiple_handles) { @@ -51,24 +51,20 @@ TEST_IMPL(poll_multiple_handles) { { struct WSAData wsa_data; int r = WSAStartup(MAKEWORD(2, 2), &wsa_data); - ASSERT_OK(r); + ASSERT(r == 0); } #endif sock = socket(AF_INET, SOCK_STREAM, 0); #ifdef _WIN32 - ASSERT_NE(sock, INVALID_SOCKET); + ASSERT(sock != INVALID_SOCKET); #else - ASSERT_NE(sock, -1); + ASSERT(sock != -1); #endif - ASSERT_OK(uv_poll_init_socket(uv_default_loop(), - &first_poll_handle, - sock)); - ASSERT_OK(uv_poll_init_socket(uv_default_loop(), - &second_poll_handle, - sock)); + ASSERT(0 == uv_poll_init_socket(uv_default_loop(), &first_poll_handle, sock)); + ASSERT(0 == uv_poll_init_socket(uv_default_loop(), &second_poll_handle, sock)); - ASSERT_OK(uv_poll_start(&first_poll_handle, UV_READABLE, poll_cb)); + ASSERT(0 == uv_poll_start(&first_poll_handle, UV_READABLE, poll_cb)); /* We may not start polling while another polling handle is active * on that fd. @@ -77,28 +73,27 @@ TEST_IMPL(poll_multiple_handles) { /* We do not track handles in an O(1) lookupable way on Windows, * so not checking that here. */ - ASSERT_EQ(uv_poll_start(&second_poll_handle, UV_READABLE, poll_cb), - UV_EEXIST); + ASSERT(uv_poll_start(&second_poll_handle, UV_READABLE, poll_cb) == UV_EEXIST); #endif /* After stopping the other polling handle, we now should be able to poll */ - ASSERT_OK(uv_poll_stop(&first_poll_handle)); - ASSERT_OK(uv_poll_start(&second_poll_handle, UV_READABLE, poll_cb)); + ASSERT(0 == uv_poll_stop(&first_poll_handle)); + ASSERT(0 == uv_poll_start(&second_poll_handle, UV_READABLE, poll_cb)); /* Closing an already stopped polling handle is safe in any case */ uv_close((uv_handle_t*) &first_poll_handle, close_cb); uv_unref((uv_handle_t*) &second_poll_handle); - ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT)); - ASSERT_EQ(1, close_cb_called); + ASSERT(0 == uv_run(uv_default_loop(), UV_RUN_DEFAULT)); + ASSERT(close_cb_called == 1); uv_ref((uv_handle_t*) &second_poll_handle); ASSERT(uv_is_active((uv_handle_t*) &second_poll_handle)); uv_close((uv_handle_t*) &second_poll_handle, close_cb); - ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT)); - ASSERT_EQ(2, close_cb_called); + ASSERT(0 == uv_run(uv_default_loop(), UV_RUN_DEFAULT)); + ASSERT(close_cb_called == 2); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-poll-oob.c b/test/test-poll-oob.c index b40c93c..77ffe31 100644 --- a/test/test-poll-oob.c +++ b/test/test-poll-oob.c @@ -70,7 +70,7 @@ static void poll_cb(uv_poll_t* handle, int status, int events) { int n; int fd; - ASSERT_OK(uv_fileno((uv_handle_t*)handle, &fd)); + ASSERT(0 == uv_fileno((uv_handle_t*)handle, &fd)); memset(buffer, 0, 5); if (events & UV_PRIORITIZED) { @@ -79,10 +79,10 @@ static void poll_cb(uv_poll_t* handle, int status, int events) { while (n == -1 && errno == EINTR); ASSERT(n >= 0 || errno != EINVAL); cli_pr_check = 1; - ASSERT_OK(uv_poll_stop(&poll_req[0])); - ASSERT_OK(uv_poll_start(&poll_req[0], - UV_READABLE | UV_WRITABLE, - poll_cb)); + ASSERT(0 == uv_poll_stop(&poll_req[0])); + ASSERT(0 == uv_poll_start(&poll_req[0], + UV_READABLE | UV_WRITABLE, + poll_cb)); } if (events & UV_READABLE) { if (fd == client_fd) { @@ -91,21 +91,21 @@ static void poll_cb(uv_poll_t* handle, int status, int events) { while (n == -1 && errno == EINTR); ASSERT(n >= 0 || errno != EINVAL); if (cli_rd_check == 1) { - ASSERT_OK(strncmp(buffer, "world", n)); - ASSERT_EQ(5, n); + ASSERT(strncmp(buffer, "world", n) == 0); + ASSERT(5 == n); cli_rd_check = 2; } if (cli_rd_check == 0) { - ASSERT_EQ(4, n); - ASSERT_OK(strncmp(buffer, "hello", n)); + ASSERT(n == 4); + ASSERT(strncmp(buffer, "hello", n) == 0); cli_rd_check = 1; do { do n = recv(server_fd, &buffer, 5, 0); while (n == -1 && errno == EINTR); if (n > 0) { - ASSERT_EQ(5, n); - ASSERT_OK(strncmp(buffer, "world", n)); + ASSERT(n == 5); + ASSERT(strncmp(buffer, "world", n) == 0); cli_rd_check = 2; } } while (n > 0); @@ -118,8 +118,8 @@ static void poll_cb(uv_poll_t* handle, int status, int events) { n = recv(server_fd, &buffer, 3, 0); while (n == -1 && errno == EINTR); ASSERT(n >= 0 || errno != EINVAL); - ASSERT_EQ(3, n); - ASSERT_OK(strncmp(buffer, "foo", n)); + ASSERT(3 == n); + ASSERT(strncmp(buffer, "foo", n) == 0); srv_rd_check = 1; uv_poll_stop(&poll_req[1]); } @@ -128,39 +128,35 @@ static void poll_cb(uv_poll_t* handle, int status, int events) { do { n = send(client_fd, "foo", 3, 0); } while (n < 0 && errno == EINTR); - ASSERT_EQ(3, n); + ASSERT(3 == n); } } static void connection_cb(uv_stream_t* handle, int status) { int r; - ASSERT_OK(status); - ASSERT_OK(uv_accept(handle, (uv_stream_t*) &peer_handle)); - ASSERT_OK(uv_fileno((uv_handle_t*) &peer_handle, &server_fd)); - ASSERT_OK(uv_poll_init_socket(uv_default_loop(), - &poll_req[0], - client_fd)); - ASSERT_OK(uv_poll_init_socket(uv_default_loop(), - &poll_req[1], - server_fd)); - ASSERT_OK(uv_poll_start(&poll_req[0], - UV_PRIORITIZED | UV_READABLE | UV_WRITABLE, - poll_cb)); - ASSERT_OK(uv_poll_start(&poll_req[1], - UV_READABLE, - poll_cb)); + ASSERT(0 == status); + ASSERT(0 == uv_accept(handle, (uv_stream_t*) &peer_handle)); + ASSERT(0 == uv_fileno((uv_handle_t*) &peer_handle, &server_fd)); + ASSERT(0 == uv_poll_init_socket(uv_default_loop(), &poll_req[0], client_fd)); + ASSERT(0 == uv_poll_init_socket(uv_default_loop(), &poll_req[1], server_fd)); + ASSERT(0 == uv_poll_start(&poll_req[0], + UV_PRIORITIZED | UV_READABLE | UV_WRITABLE, + poll_cb)); + ASSERT(0 == uv_poll_start(&poll_req[1], + UV_READABLE, + poll_cb)); do { r = send(server_fd, "hello", 5, MSG_OOB); } while (r < 0 && errno == EINTR); - ASSERT_EQ(5, r); + ASSERT(5 == r); do { r = send(server_fd, "world", 5, 0); } while (r < 0 && errno == EINTR); - ASSERT_EQ(5, r); + ASSERT(5 == r); - ASSERT_OK(uv_idle_start(&idle, idle_cb)); + ASSERT(0 == uv_idle_start(&idle, idle_cb)); } @@ -169,41 +165,41 @@ TEST_IMPL(poll_oob) { int r = 0; uv_loop_t* loop; - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); + ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); loop = uv_default_loop(); - ASSERT_OK(uv_tcp_init(loop, &server_handle)); - ASSERT_OK(uv_tcp_init(loop, &client_handle)); - ASSERT_OK(uv_tcp_init(loop, &peer_handle)); - ASSERT_OK(uv_idle_init(loop, &idle)); - ASSERT_OK(uv_tcp_bind(&server_handle, (const struct sockaddr*) &addr, 0)); - ASSERT_OK(uv_listen((uv_stream_t*) &server_handle, 1, connection_cb)); + ASSERT(0 == uv_tcp_init(loop, &server_handle)); + ASSERT(0 == uv_tcp_init(loop, &client_handle)); + ASSERT(0 == uv_tcp_init(loop, &peer_handle)); + ASSERT(0 == uv_idle_init(loop, &idle)); + ASSERT(0 == uv_tcp_bind(&server_handle, (const struct sockaddr*) &addr, 0)); + ASSERT(0 == uv_listen((uv_stream_t*) &server_handle, 1, connection_cb)); /* Ensure two separate packets */ - ASSERT_OK(uv_tcp_nodelay(&client_handle, 1)); + ASSERT(0 == uv_tcp_nodelay(&client_handle, 1)); client_fd = socket(PF_INET, SOCK_STREAM, 0); - ASSERT_GE(client_fd, 0); + ASSERT(client_fd >= 0); do { errno = 0; r = connect(client_fd, (const struct sockaddr*)&addr, sizeof(addr)); } while (r == -1 && errno == EINTR); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_OK(uv_run(loop, UV_RUN_DEFAULT)); + ASSERT(0 == uv_run(loop, UV_RUN_DEFAULT)); - ASSERT_EQ(ticks, kMaxTicks); + ASSERT(ticks == kMaxTicks); /* Did client receive the POLLPRI message */ - ASSERT_EQ(1, cli_pr_check); + ASSERT(cli_pr_check == 1); /* Did client receive the POLLIN message */ - ASSERT_EQ(2, cli_rd_check); + ASSERT(cli_rd_check == 2); /* Could we write with POLLOUT and did the server receive our POLLOUT message * through POLLIN. */ - ASSERT_EQ(1, srv_rd_check); + ASSERT(srv_rd_check == 1); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-poll.c b/test/test-poll.c index fcd644f..3bc422d 100644 --- a/test/test-poll.c +++ b/test/test-poll.c @@ -23,7 +23,6 @@ #ifdef _WIN32 # include -# define close _close #else # include # include @@ -107,9 +106,9 @@ static uv_os_sock_t create_bound_socket (struct sockaddr_in bind_addr) { sock = socket(AF_INET, SOCK_STREAM, IPPROTO_IP); #ifdef _WIN32 - ASSERT_NE(sock, INVALID_SOCKET); + ASSERT(sock != INVALID_SOCKET); #else - ASSERT_GE(sock, 0); + ASSERT(sock >= 0); #endif #ifndef _WIN32 @@ -117,12 +116,12 @@ static uv_os_sock_t create_bound_socket (struct sockaddr_in bind_addr) { /* Allow reuse of the port. */ int yes = 1; r = setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof yes); - ASSERT_OK(r); + ASSERT(r == 0); } #endif r = bind(sock, (const struct sockaddr*) &bind_addr, sizeof bind_addr); - ASSERT_OK(r); + ASSERT(r == 0); return sock; } @@ -164,12 +163,12 @@ static connection_context_t* create_connection_context( r = uv_poll_init_socket(uv_default_loop(), &context->poll_handle, sock); context->open_handles++; context->poll_handle.data = context; - ASSERT_OK(r); + ASSERT(r == 0); r = uv_timer_init(uv_default_loop(), &context->timer_handle); context->open_handles++; context->timer_handle.data = context; - ASSERT_OK(r); + ASSERT(r == 0); return context; } @@ -180,15 +179,15 @@ static void connection_close_cb(uv_handle_t* handle) { if (--context->open_handles == 0) { if (test_mode == DUPLEX || context->is_server_connection) { - ASSERT_EQ(context->read, TRANSFER_BYTES); + ASSERT(context->read == TRANSFER_BYTES); } else { - ASSERT_OK(context->read); + ASSERT(context->read == 0); } if (test_mode == DUPLEX || !context->is_server_connection) { - ASSERT_EQ(context->sent, TRANSFER_BYTES); + ASSERT(context->sent == TRANSFER_BYTES); } else { - ASSERT_OK(context->sent); + ASSERT(context->sent == 0); } closed_connections++; @@ -209,7 +208,7 @@ static void connection_poll_cb(uv_poll_t* handle, int status, int events) { unsigned int new_events; int r; - ASSERT_OK(status); + ASSERT(status == 0); ASSERT(events & context->events); ASSERT(!(events & ~context->events)); @@ -227,7 +226,7 @@ static void connection_poll_cb(uv_poll_t* handle, int status, int events) { do r = recv(context->sock, buffer, sizeof buffer, 0); while (r == -1 && errno == EINTR); - ASSERT_GE(r, 0); + ASSERT(r >= 0); if (r > 0) { context->read += r; @@ -307,7 +306,7 @@ static void connection_poll_cb(uv_poll_t* handle, int status, int events) { static char buffer[103]; int send_bytes = MIN(TRANSFER_BYTES - context->sent, sizeof buffer); - ASSERT_GT(send_bytes, 0); + ASSERT(send_bytes > 0); do r = send(context->sock, buffer, send_bytes, 0); @@ -319,7 +318,7 @@ static void connection_poll_cb(uv_poll_t* handle, int status, int events) { break; } - ASSERT_GT(r, 0); + ASSERT(r > 0); context->sent += r; valid_writable_wakeups++; break; @@ -331,7 +330,7 @@ static void connection_poll_cb(uv_poll_t* handle, int status, int events) { static char buffer[1234]; int send_bytes = MIN(TRANSFER_BYTES - context->sent, sizeof buffer); - ASSERT_GT(send_bytes, 0); + ASSERT(send_bytes > 0); do r = send(context->sock, buffer, send_bytes, 0); @@ -343,18 +342,18 @@ static void connection_poll_cb(uv_poll_t* handle, int status, int events) { break; } - ASSERT_GT(r, 0); + ASSERT(r > 0); valid_writable_wakeups++; context->sent += r; while (context->sent < TRANSFER_BYTES) { send_bytes = MIN(TRANSFER_BYTES - context->sent, sizeof buffer); - ASSERT_GT(send_bytes, 0); + ASSERT(send_bytes > 0); do r = send(context->sock, buffer, send_bytes, 0); while (r == -1 && errno == EINTR); - ASSERT(r); + ASSERT(r != 0); if (r < 0) { ASSERT(got_eagain()); @@ -404,7 +403,7 @@ static void connection_poll_cb(uv_poll_t* handle, int status, int events) { #else r = shutdown(context->sock, SHUT_WR); #endif - ASSERT_OK(r); + ASSERT(r == 0); context->sent_fin = 1; new_events &= ~UV_WRITABLE; } @@ -433,9 +432,9 @@ static void connection_poll_cb(uv_poll_t* handle, int status, int events) { /* Assert that uv_is_active works correctly for poll handles. */ if (context->events != 0) { - ASSERT_EQ(1, uv_is_active((uv_handle_t*) handle)); + ASSERT(1 == uv_is_active((uv_handle_t*) handle)); } else { - ASSERT_OK(uv_is_active((uv_handle_t*) handle)); + ASSERT(0 == uv_is_active((uv_handle_t*) handle)); } } @@ -445,7 +444,7 @@ static void delay_timer_cb(uv_timer_t* timer) { int r; /* Timer should auto stop. */ - ASSERT_OK(uv_is_active((uv_handle_t*) timer)); + ASSERT(0 == uv_is_active((uv_handle_t*) timer)); /* Add the requested events to the poll mask. */ ASSERT(context->delayed_events != 0); @@ -455,7 +454,7 @@ static void delay_timer_cb(uv_timer_t* timer) { r = uv_poll_start(&context->poll_handle, context->events, connection_poll_cb); - ASSERT_OK(r); + ASSERT(r == 0); } @@ -472,7 +471,7 @@ static server_context_t* create_server_context( r = uv_poll_init_socket(uv_default_loop(), &context->poll_handle, sock); context->poll_handle.data = context; - ASSERT_OK(r); + ASSERT(r == 0); return context; } @@ -501,9 +500,9 @@ static void server_poll_cb(uv_poll_t* handle, int status, int events) { addr_len = sizeof addr; sock = accept(server_context->sock, (struct sockaddr*) &addr, &addr_len); #ifdef _WIN32 - ASSERT_NE(sock, INVALID_SOCKET); + ASSERT(sock != INVALID_SOCKET); #else - ASSERT_GE(sock, 0); + ASSERT(sock >= 0); #endif connection_context = create_connection_context(sock, 1); @@ -511,7 +510,7 @@ static void server_poll_cb(uv_poll_t* handle, int status, int events) { r = uv_poll_start(&connection_context->poll_handle, UV_READABLE | UV_WRITABLE | UV_DISCONNECT, connection_poll_cb); - ASSERT_OK(r); + ASSERT(r == 0); if (++server_context->connections == NUM_CLIENTS) { close_socket(server_context->sock); @@ -526,15 +525,15 @@ static void start_server(void) { uv_os_sock_t sock; int r; - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); + ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); sock = create_bound_socket(addr); context = create_server_context(sock); r = listen(sock, 100); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_poll_start(&context->poll_handle, UV_READABLE, server_poll_cb); - ASSERT_OK(r); + ASSERT(r == 0); } @@ -545,8 +544,8 @@ static void start_client(void) { struct sockaddr_in addr; int r; - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &server_addr)); - ASSERT_OK(uv_ip4_addr("0.0.0.0", 0, &addr)); + ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &server_addr)); + ASSERT(0 == uv_ip4_addr("0.0.0.0", 0, &addr)); sock = create_bound_socket(addr); context = create_connection_context(sock, 0); @@ -555,7 +554,7 @@ static void start_client(void) { r = uv_poll_start(&context->poll_handle, UV_READABLE | UV_WRITABLE | UV_DISCONNECT, connection_poll_cb); - ASSERT_OK(r); + ASSERT(r == 0); r = connect(sock, (struct sockaddr*) &server_addr, sizeof server_addr); ASSERT(r == 0 || got_eagain()); @@ -569,7 +568,7 @@ static void start_poll_test(void) { { struct WSAData wsa_data; int r = WSAStartup(MAKEWORD(2, 2), &wsa_data); - ASSERT_OK(r); + ASSERT(r == 0); } #endif @@ -579,18 +578,18 @@ static void start_poll_test(void) { start_client(); r = uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_OK(r); + ASSERT(r == 0); /* Assert that at most five percent of the writable wakeups was spurious. */ - ASSERT_NE(spurious_writable_wakeups == 0 || - (valid_writable_wakeups + spurious_writable_wakeups) / - spurious_writable_wakeups > 20, 0); + ASSERT(spurious_writable_wakeups == 0 || + (valid_writable_wakeups + spurious_writable_wakeups) / + spurious_writable_wakeups > 20); - ASSERT_EQ(closed_connections, NUM_CLIENTS * 2); + ASSERT(closed_connections == NUM_CLIENTS * 2); #if !defined(__sun) && !defined(_AIX) && !defined(__MVS__) - ASSERT_EQ(disconnects, NUM_CLIENTS * 2); + ASSERT(disconnects == NUM_CLIENTS * 2); #endif - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); } @@ -632,23 +631,23 @@ TEST_IMPL(poll_unidirectional) { */ TEST_IMPL(poll_bad_fdtype) { #if !defined(__DragonFly__) && !defined(__FreeBSD__) && !defined(__sun) && \ - !defined(_AIX) && !defined(__MVS__) && \ + !defined(_AIX) && !defined(__MVS__) && !defined(__FreeBSD_kernel__) && \ !defined(__OpenBSD__) && !defined(__CYGWIN__) && !defined(__MSYS__) && \ !defined(__NetBSD__) uv_poll_t poll_handle; int fd; #if defined(_WIN32) - fd = _open("test/fixtures/empty_file", UV_FS_O_RDONLY); + fd = open("test/fixtures/empty_file", O_RDONLY); #else - fd = open(".", UV_FS_O_RDONLY); + fd = open(".", O_RDONLY); #endif - ASSERT_NE(fd, -1); - ASSERT_NE(0, uv_poll_init(uv_default_loop(), &poll_handle, fd)); - ASSERT_OK(close(fd)); + ASSERT(fd != -1); + ASSERT(0 != uv_poll_init(uv_default_loop(), &poll_handle, fd)); + ASSERT(0 == close(fd)); #endif - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -659,17 +658,17 @@ TEST_IMPL(poll_nested_epoll) { int fd; fd = epoll_create(1); - ASSERT_NE(fd, -1); + ASSERT(fd != -1); - ASSERT_OK(uv_poll_init(uv_default_loop(), &poll_handle, fd)); - ASSERT_OK(uv_poll_start(&poll_handle, UV_READABLE, (uv_poll_cb) abort)); - ASSERT_NE(0, uv_run(uv_default_loop(), UV_RUN_NOWAIT)); + ASSERT(0 == uv_poll_init(uv_default_loop(), &poll_handle, fd)); + ASSERT(0 == uv_poll_start(&poll_handle, UV_READABLE, (uv_poll_cb) abort)); + ASSERT(0 != uv_run(uv_default_loop(), UV_RUN_NOWAIT)); uv_close((uv_handle_t*) &poll_handle, NULL); - ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT)); - ASSERT_OK(close(fd)); + ASSERT(0 == uv_run(uv_default_loop(), UV_RUN_DEFAULT)); + ASSERT(0 == close(fd)); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } #endif /* __linux__ */ @@ -681,17 +680,17 @@ TEST_IMPL(poll_nested_kqueue) { int fd; fd = kqueue(); - ASSERT_NE(fd, -1); + ASSERT(fd != -1); - ASSERT_OK(uv_poll_init(uv_default_loop(), &poll_handle, fd)); - ASSERT_OK(uv_poll_start(&poll_handle, UV_READABLE, (uv_poll_cb) abort)); - ASSERT_NE(0, uv_run(uv_default_loop(), UV_RUN_NOWAIT)); + ASSERT(0 == uv_poll_init(uv_default_loop(), &poll_handle, fd)); + ASSERT(0 == uv_poll_start(&poll_handle, UV_READABLE, (uv_poll_cb) abort)); + ASSERT(0 != uv_run(uv_default_loop(), UV_RUN_NOWAIT)); uv_close((uv_handle_t*) &poll_handle, NULL); - ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT)); - ASSERT_OK(close(fd)); + ASSERT(0 == uv_run(uv_default_loop(), UV_RUN_DEFAULT)); + ASSERT(0 == close(fd)); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } #endif /* UV_HAVE_KQUEUE */ diff --git a/test/test-process-priority.c b/test/test-process-priority.c index 941e4b3..b3d0a85 100644 --- a/test/test-process-priority.c +++ b/test/test-process-priority.c @@ -35,7 +35,7 @@ TEST_IMPL(process_priority) { /* Verify that passing a NULL pointer returns UV_EINVAL. */ r = uv_os_getpriority(0, NULL); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); /* Verify that all valid values work. */ for (i = UV_PRIORITY_HIGHEST; i <= UV_PRIORITY_LOW; i++) { @@ -46,38 +46,38 @@ TEST_IMPL(process_priority) { if (r == UV_EACCES) continue; - ASSERT_OK(r); - ASSERT_OK(uv_os_getpriority(0, &priority)); + ASSERT(r == 0); + ASSERT(uv_os_getpriority(0, &priority) == 0); /* Verify that the priority values match on Unix, and are range mapped on Windows. */ #ifndef _WIN32 - ASSERT_EQ(priority, i); + ASSERT(priority == i); #else /* On Windows, only elevated users can set UV_PRIORITY_HIGHEST. Other users will silently be set to UV_PRIORITY_HIGH. */ if (i < UV_PRIORITY_HIGH) ASSERT(priority == UV_PRIORITY_HIGHEST || priority == UV_PRIORITY_HIGH); else if (i < UV_PRIORITY_ABOVE_NORMAL) - ASSERT_EQ(priority, UV_PRIORITY_HIGH); + ASSERT(priority == UV_PRIORITY_HIGH); else if (i < UV_PRIORITY_NORMAL) - ASSERT_EQ(priority, UV_PRIORITY_ABOVE_NORMAL); + ASSERT(priority == UV_PRIORITY_ABOVE_NORMAL); else if (i < UV_PRIORITY_BELOW_NORMAL) - ASSERT_EQ(priority, UV_PRIORITY_NORMAL); + ASSERT(priority == UV_PRIORITY_NORMAL); else if (i < UV_PRIORITY_LOW) - ASSERT_EQ(priority, UV_PRIORITY_BELOW_NORMAL); + ASSERT(priority == UV_PRIORITY_BELOW_NORMAL); else - ASSERT_EQ(priority, UV_PRIORITY_LOW); + ASSERT(priority == UV_PRIORITY_LOW); #endif /* Verify that the current PID and 0 are equivalent. */ - ASSERT_OK(uv_os_getpriority(uv_os_getpid(), &r)); - ASSERT_EQ(priority, r); + ASSERT(uv_os_getpriority(uv_os_getpid(), &r) == 0); + ASSERT(priority == r); } /* Verify that invalid priorities return UV_EINVAL. */ - ASSERT_EQ(uv_os_setpriority(0, UV_PRIORITY_HIGHEST - 1), UV_EINVAL); - ASSERT_EQ(uv_os_setpriority(0, UV_PRIORITY_LOW + 1), UV_EINVAL); + ASSERT(uv_os_setpriority(0, UV_PRIORITY_HIGHEST - 1) == UV_EINVAL); + ASSERT(uv_os_setpriority(0, UV_PRIORITY_LOW + 1) == UV_EINVAL); return 0; } diff --git a/test/test-process-title-threadsafe.c b/test/test-process-title-threadsafe.c index 05baaf4..927643c 100644 --- a/test/test-process-title-threadsafe.c +++ b/test/test-process-title-threadsafe.c @@ -46,7 +46,7 @@ static void getter_thread_body(void* arg) { getter_sem = arg; while (UV_EAGAIN == uv_sem_trywait(getter_sem)) { - ASSERT_OK(uv_get_process_title(buffer, sizeof(buffer))); + ASSERT(0 == uv_get_process_title(buffer, sizeof(buffer))); /* The maximum size of the process title on some platforms depends on * the total size of the argv vector. It's therefore possible to read @@ -70,10 +70,10 @@ static void setter_thread_body(void* arg) { int i; for (i = 0; i < NUM_ITERATIONS; i++) { - ASSERT_OK(uv_set_process_title(titles[0])); - ASSERT_OK(uv_set_process_title(titles[1])); - ASSERT_OK(uv_set_process_title(titles[2])); - ASSERT_OK(uv_set_process_title(titles[3])); + ASSERT(0 == uv_set_process_title(titles[0])); + ASSERT(0 == uv_set_process_title(titles[1])); + ASSERT(0 == uv_set_process_title(titles[2])); + ASSERT(0 == uv_set_process_title(titles[3])); } } @@ -89,19 +89,20 @@ TEST_IMPL(process_title_threadsafe) { RETURN_SKIP("uv_(get|set)_process_title is not implemented."); #endif - ASSERT_OK(uv_set_process_title(titles[0])); + ASSERT(0 == uv_set_process_title(titles[0])); - ASSERT_OK(uv_sem_init(&getter_sem, 0)); - ASSERT_OK(uv_thread_create(&getter_thread, getter_thread_body, &getter_sem)); + ASSERT_EQ(0, uv_sem_init(&getter_sem, 0)); + ASSERT_EQ(0, + uv_thread_create(&getter_thread, getter_thread_body, &getter_sem)); for (i = 0; i < (int) ARRAY_SIZE(setter_threads); i++) - ASSERT_OK(uv_thread_create(&setter_threads[i], setter_thread_body, NULL)); + ASSERT(0 == uv_thread_create(&setter_threads[i], setter_thread_body, NULL)); for (i = 0; i < (int) ARRAY_SIZE(setter_threads); i++) - ASSERT_OK(uv_thread_join(&setter_threads[i])); + ASSERT(0 == uv_thread_join(&setter_threads[i])); uv_sem_post(&getter_sem); - ASSERT_OK(uv_thread_join(&getter_thread)); + ASSERT_EQ(0, uv_thread_join(&getter_thread)); uv_sem_destroy(&getter_sem); return 0; diff --git a/test/test-process-title.c b/test/test-process-title.c index 7178cf8..35a1480 100644 --- a/test/test-process-title.c +++ b/test/test-process-title.c @@ -29,15 +29,15 @@ static void set_title(const char* title) { int err; err = uv_get_process_title(buffer, sizeof(buffer)); - ASSERT_OK(err); + ASSERT(err == 0); err = uv_set_process_title(title); - ASSERT_OK(err); + ASSERT(err == 0); err = uv_get_process_title(buffer, sizeof(buffer)); - ASSERT_OK(err); + ASSERT(err == 0); - ASSERT_OK(strcmp(buffer, title)); + ASSERT(strcmp(buffer, title) == 0); } @@ -47,15 +47,15 @@ static void uv_get_process_title_edge_cases(void) { /* Test a NULL buffer */ r = uv_get_process_title(NULL, 100); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); /* Test size of zero */ r = uv_get_process_title(buffer, 0); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); /* Test for insufficient buffer size */ r = uv_get_process_title(buffer, 1); - ASSERT_EQ(r, UV_ENOBUFS); + ASSERT(r == UV_ENOBUFS); } @@ -77,8 +77,8 @@ TEST_IMPL(process_title) { static void exit_cb(uv_process_t* process, int64_t status, int signo) { - ASSERT_OK(status); - ASSERT_OK(signo); + ASSERT(status == 0); + ASSERT(signo == 0); uv_close((uv_handle_t*) process, NULL); } @@ -97,7 +97,7 @@ TEST_IMPL(process_title_big_argv) { #endif exepath_size = sizeof(exepath) - 1; - ASSERT_OK(uv_exepath(exepath, &exepath_size)); + ASSERT(0 == uv_exepath(exepath, &exepath_size)); exepath[exepath_size] = '\0'; memset(jumbo, 'x', sizeof(jumbo) - 1); @@ -117,10 +117,10 @@ TEST_IMPL(process_title_big_argv) { options.args = args; options.exit_cb = exit_cb; - ASSERT_OK(uv_spawn(uv_default_loop(), &process, &options)); - ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT)); + ASSERT(0 == uv_spawn(uv_default_loop(), &process, &options)); + ASSERT(0 == uv_run(uv_default_loop(), UV_RUN_DEFAULT)); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -131,5 +131,5 @@ void process_title_big_argv(void) { /* Return value deliberately ignored. */ uv_get_process_title(buf, sizeof(buf)); - ASSERT_NE(0, strcmp(buf, "fail")); + ASSERT(0 != strcmp(buf, "fail")); } diff --git a/test/test-queue-foreach-delete.c b/test/test-queue-foreach-delete.c index b3a2d19..049ea77 100644 --- a/test/test-queue-foreach-delete.c +++ b/test/test-queue-foreach-delete.c @@ -29,7 +29,7 @@ * The idea behind the test is as follows. * Certain handle types are stored in a queue internally. * Extra care should be taken for removal of a handle from the queue while iterating over the queue. - * (i.e., uv__queue_remove() called within uv__queue_foreach()) + * (i.e., QUEUE_REMOVE() called within QUEUE_FOREACH()) * This usually happens when someone closes or stops a handle from within its callback. * So we need to check that we haven't screwed the queue on close/stop. * To do so we do the following (for each handle type): @@ -54,8 +54,7 @@ * wrong foreach "next" | * * 4. The callback for handle #1 shouldn't be called because the handle #1 is stopped in the previous step. - * However, if uv__queue_remove() is not handled properly within uv__queue_foreach(), the callback _will_ - * be called. + * However, if QUEUE_REMOVE() is not handled properly within QUEUE_FOREACH(), the callback _will_ be called. */ static const unsigned first_handle_number_idle = 2; @@ -71,7 +70,7 @@ static const unsigned first_handle_number_fs_event = 0; static unsigned name##_cb_calls[3]; \ \ static void name##2_cb(__VA_ARGS__) { \ - ASSERT_PTR_EQ(handle, &(name)[2]); \ + ASSERT(handle == &(name)[2]); \ if (first_handle_number_##name == 2) { \ uv_close((uv_handle_t*)&(name)[2], NULL); \ uv_close((uv_handle_t*)&(name)[1], NULL); \ @@ -80,12 +79,12 @@ static const unsigned first_handle_number_fs_event = 0; } \ \ static void name##1_cb(__VA_ARGS__) { \ - ASSERT_PTR_EQ(handle, &(name)[1]); \ + ASSERT(handle == &(name)[1]); \ ASSERT(0 && "Shouldn't be called" && (&name[0])); \ } \ \ static void name##0_cb(__VA_ARGS__) { \ - ASSERT_PTR_EQ(handle, &(name)[0]); \ + ASSERT(handle == &(name)[0]); \ if (first_handle_number_##name == 0) { \ uv_close((uv_handle_t*)&(name)[0], NULL); \ uv_close((uv_handle_t*)&(name)[1], NULL); \ @@ -105,18 +104,18 @@ static const unsigned first_handle_number_fs_event = 0; for (i = 0; i < ARRAY_SIZE(name); i++) { \ int r; \ r = uv_##name##_init((loop), &(name)[i]); \ - ASSERT_OK(r); \ + ASSERT(r == 0); \ \ r = uv_##name##_start(&(name)[i], name##_cbs[i]); \ - ASSERT_OK(r); \ + ASSERT(r == 0); \ } \ } while (0) #define END_ASSERTS(name) \ do { \ - ASSERT_EQ(1, name##_cb_calls[0]); \ - ASSERT_OK(name##_cb_calls[1]); \ - ASSERT_EQ(1, name##_cb_calls[2]); \ + ASSERT(name##_cb_calls[0] == 1); \ + ASSERT(name##_cb_calls[1] == 0); \ + ASSERT(name##_cb_calls[2] == 1); \ } while (0) DEFINE_GLOBALS_AND_CBS(idle, uv_idle_t* handle) @@ -140,13 +139,13 @@ static void init_and_start_fs_events(uv_loop_t* loop) { for (i = 0; i < ARRAY_SIZE(fs_event); i++) { int r; r = uv_fs_event_init(loop, &fs_event[i]); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_fs_event_start(&fs_event[i], (uv_fs_event_cb)fs_event_cbs[i], watched_dir, 0); - ASSERT_OK(r); + ASSERT(r == 0); } } @@ -156,10 +155,10 @@ static void helper_timer_cb(uv_timer_t* thandle) { /* fire all fs_events */ r = uv_fs_utime(thandle->loop, &fs_req, watched_dir, 0, 0, NULL); - ASSERT_OK(r); - ASSERT_OK(fs_req.result); - ASSERT_EQ(fs_req.fs_type, UV_FS_UTIME); - ASSERT_OK(strcmp(fs_req.path, watched_dir)); + ASSERT(r == 0); + ASSERT(fs_req.result == 0); + ASSERT(fs_req.fs_type == UV_FS_UTIME); + ASSERT(strcmp(fs_req.path, watched_dir) == 0); uv_fs_req_cleanup(&fs_req); helper_timer_cb_calls++; @@ -182,24 +181,24 @@ TEST_IMPL(queue_foreach_delete) { /* helper timer to trigger async and fs_event callbacks */ r = uv_timer_init(loop, &timer); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_timer_start(&timer, helper_timer_cb, 0, 0); - ASSERT_OK(r); + ASSERT(r == 0); #endif r = uv_run(loop, UV_RUN_NOWAIT); - ASSERT_EQ(1, r); + ASSERT(r == 1); END_ASSERTS(idle); END_ASSERTS(prepare); END_ASSERTS(check); #ifdef __linux__ - ASSERT_EQ(1, helper_timer_cb_calls); + ASSERT(helper_timer_cb_calls == 1); #endif - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-random.c b/test/test-random.c index d82d057..2e3ce44 100644 --- a/test/test-random.c +++ b/test/test-random.c @@ -33,16 +33,16 @@ static void random_cb(uv_random_t* req, int status, void* buf, size_t buflen) { memset(zero, 0, sizeof(zero)); - ASSERT_OK(status); - ASSERT_PTR_EQ(buf, (void*) scratch); + ASSERT(0 == status); + ASSERT(buf == (void*) scratch); if (random_cb_called == 0) { - ASSERT_OK(buflen); - ASSERT_OK(memcmp(scratch, zero, sizeof(zero))); + ASSERT(buflen == 0); + ASSERT(0 == memcmp(scratch, zero, sizeof(zero))); } else { - ASSERT_EQ(buflen, sizeof(scratch)); + ASSERT(buflen == sizeof(scratch)); /* Buy a lottery ticket if you manage to trip this assertion. */ - ASSERT_NE(0, memcmp(scratch, zero, sizeof(zero))); + ASSERT(0 != memcmp(scratch, zero, sizeof(zero))); } random_cb_called++; @@ -54,23 +54,23 @@ TEST_IMPL(random_async) { uv_loop_t* loop; loop = uv_default_loop(); - ASSERT_EQ(UV_EINVAL, uv_random(loop, &req, scratch, sizeof(scratch), -1, - random_cb)); - ASSERT_EQ(UV_E2BIG, uv_random(loop, &req, scratch, -1, -1, random_cb)); + ASSERT(UV_EINVAL == uv_random(loop, &req, scratch, sizeof(scratch), -1, + random_cb)); + ASSERT(UV_E2BIG == uv_random(loop, &req, scratch, -1, -1, random_cb)); - ASSERT_OK(uv_random(loop, &req, scratch, 0, 0, random_cb)); - ASSERT_OK(random_cb_called); + ASSERT(0 == uv_random(loop, &req, scratch, 0, 0, random_cb)); + ASSERT(0 == random_cb_called); - ASSERT_OK(uv_run(loop, UV_RUN_DEFAULT)); - ASSERT_EQ(1, random_cb_called); + ASSERT(0 == uv_run(loop, UV_RUN_DEFAULT)); + ASSERT(1 == random_cb_called); - ASSERT_OK(uv_random(loop, &req, scratch, sizeof(scratch), 0, random_cb)); - ASSERT_EQ(1, random_cb_called); + ASSERT(0 == uv_random(loop, &req, scratch, sizeof(scratch), 0, random_cb)); + ASSERT(1 == random_cb_called); - ASSERT_OK(uv_run(loop, UV_RUN_DEFAULT)); - ASSERT_EQ(2, random_cb_called); + ASSERT(0 == uv_run(loop, UV_RUN_DEFAULT)); + ASSERT(2 == random_cb_called); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -79,16 +79,16 @@ TEST_IMPL(random_sync) { char zero[256]; char buf[256]; - ASSERT_EQ(UV_EINVAL, uv_random(NULL, NULL, buf, sizeof(buf), -1, NULL)); - ASSERT_EQ(UV_E2BIG, uv_random(NULL, NULL, buf, -1, -1, NULL)); + ASSERT(UV_EINVAL == uv_random(NULL, NULL, buf, sizeof(buf), -1, NULL)); + ASSERT(UV_E2BIG == uv_random(NULL, NULL, buf, -1, -1, NULL)); memset(buf, 0, sizeof(buf)); - ASSERT_OK(uv_random(NULL, NULL, buf, sizeof(buf), 0, NULL)); + ASSERT(0 == uv_random(NULL, NULL, buf, sizeof(buf), 0, NULL)); /* Buy a lottery ticket if you manage to trip this assertion. */ memset(zero, 0, sizeof(zero)); - ASSERT_NE(0, memcmp(buf, zero, sizeof(zero))); + ASSERT(0 != memcmp(buf, zero, sizeof(zero))); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-readable-on-eof.c b/test/test-readable-on-eof.c index 2137ac5..68e8454 100644 --- a/test/test-readable-on-eof.c +++ b/test/test-readable-on-eof.c @@ -35,7 +35,7 @@ static int close_cb_called; static void write_cb(uv_write_t* req, int status) { write_cb_called++; - ASSERT_OK(status); + ASSERT_EQ(status, 0); } static void alloc_cb(uv_handle_t* handle, @@ -54,16 +54,16 @@ static void read_cb(uv_stream_t* handle, ssize_t nread, const uv_buf_t* buf) { int r; ASSERT_EQ(nread, UV_EOF); - ASSERT_EQ(1, uv_is_readable(handle)); - ASSERT_EQ(1, uv_is_writable(handle)); + ASSERT_EQ(uv_is_readable(handle), 1); + ASSERT_EQ(uv_is_writable(handle), 1); if (++read_cb_called == 3) { uv_close((uv_handle_t*) handle, close_cb); - ASSERT_OK(uv_is_readable(handle)); - ASSERT_OK(uv_is_writable(handle)); + ASSERT_EQ(uv_is_readable(handle), 0); + ASSERT_EQ(uv_is_writable(handle), 0); } else { r = uv_read_start((uv_stream_t*) &tcp_client, alloc_cb, read_cb); - ASSERT_OK(r); + ASSERT_EQ(r, 0); } } @@ -72,7 +72,7 @@ static void connect_cb(uv_connect_t* req, int status) { uv_buf_t close_me; connect_cb_called++; - ASSERT_OK(status); + ASSERT_EQ(status, 0); read_cb((uv_stream_t*) &tcp_client, UV_EOF, NULL); @@ -84,27 +84,28 @@ static void connect_cb(uv_connect_t* req, int status) { 1, write_cb); - ASSERT_OK(r); + ASSERT_EQ(r, 0); } TEST_IMPL(readable_on_eof) { struct sockaddr_in sa; - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &sa)); - ASSERT_OK(uv_loop_init(&loop)); - ASSERT_OK(uv_tcp_init(&loop, &tcp_client)); + ASSERT_EQ(uv_ip4_addr("127.0.0.1", TEST_PORT, &sa), 0); + ASSERT_EQ(uv_loop_init(&loop), 0); + ASSERT_EQ(uv_tcp_init(&loop, &tcp_client), 0); - ASSERT_OK(uv_tcp_connect(&connect_req, + ASSERT_EQ(uv_tcp_connect(&connect_req, &tcp_client, (const struct sockaddr*) &sa, - connect_cb)); + connect_cb), + 0); - ASSERT_OK(uv_run(&loop, UV_RUN_DEFAULT)); + ASSERT_EQ(uv_run(&loop, UV_RUN_DEFAULT), 0); - ASSERT_EQ(1, connect_cb_called); - ASSERT_EQ(3, read_cb_called); - ASSERT_EQ(1, write_cb_called); - ASSERT_EQ(1, close_cb_called); + ASSERT_EQ(connect_cb_called, 1); + ASSERT_EQ(read_cb_called, 3); + ASSERT_EQ(write_cb_called, 1); + ASSERT_EQ(close_cb_called, 1); - MAKE_VALGRIND_HAPPY(&loop); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-ref.c b/test/test-ref.c index dbe94f7..d24ea4a 100644 --- a/test/test-ref.c +++ b/test/test-ref.c @@ -47,9 +47,9 @@ static void close_cb(uv_handle_t* handle) { static void do_close(void* handle) { close_cb_called = 0; uv_close((uv_handle_t*)handle, close_cb); - ASSERT_OK(close_cb_called); + ASSERT(close_cb_called == 0); uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_EQ(1, close_cb_called); + ASSERT(close_cb_called == 1); } @@ -69,13 +69,13 @@ static void req_cb(uv_handle_t* req, int status) { static void shutdown_cb(uv_shutdown_t* req, int status) { - ASSERT_PTR_EQ(req, &shutdown_req); + ASSERT(req == &shutdown_req); shutdown_cb_called++; } static void write_cb(uv_write_t* req, int status) { - ASSERT_PTR_EQ(req, &write_req); + ASSERT(req == &write_req); uv_shutdown(&shutdown_req, req->handle, shutdown_cb); write_cb_called++; } @@ -83,8 +83,8 @@ static void write_cb(uv_write_t* req, int status) { static void connect_and_write(uv_connect_t* req, int status) { uv_buf_t buf = uv_buf_init(buffer, sizeof buffer); - ASSERT_PTR_EQ(req, &connect_req); - ASSERT_OK(status); + ASSERT(req == &connect_req); + ASSERT(status == 0); uv_write(&write_req, req->handle, &buf, 1, write_cb); connect_cb_called++; } @@ -92,8 +92,8 @@ static void connect_and_write(uv_connect_t* req, int status) { static void connect_and_shutdown(uv_connect_t* req, int status) { - ASSERT_PTR_EQ(req, &connect_req); - ASSERT_OK(status); + ASSERT(req == &connect_req); + ASSERT(status == 0); uv_shutdown(&shutdown_req, req->handle, shutdown_cb); connect_cb_called++; } @@ -101,7 +101,7 @@ static void connect_and_shutdown(uv_connect_t* req, int status) { TEST_IMPL(ref) { uv_run(uv_default_loop(), UV_RUN_DEFAULT); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -113,7 +113,7 @@ TEST_IMPL(idle_ref) { uv_unref((uv_handle_t*)&h); uv_run(uv_default_loop(), UV_RUN_DEFAULT); do_close(&h); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -124,7 +124,7 @@ TEST_IMPL(async_ref) { uv_unref((uv_handle_t*)&h); uv_run(uv_default_loop(), UV_RUN_DEFAULT); do_close(&h); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -136,7 +136,7 @@ TEST_IMPL(prepare_ref) { uv_unref((uv_handle_t*)&h); uv_run(uv_default_loop(), UV_RUN_DEFAULT); do_close(&h); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -148,7 +148,7 @@ TEST_IMPL(check_ref) { uv_unref((uv_handle_t*)&h); uv_run(uv_default_loop(), UV_RUN_DEFAULT); do_close(&h); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -165,7 +165,7 @@ TEST_IMPL(unref_in_prepare_cb) { uv_prepare_start(&h, prepare_cb); uv_run(uv_default_loop(), UV_RUN_DEFAULT); do_close(&h); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -176,7 +176,7 @@ TEST_IMPL(timer_ref) { uv_unref((uv_handle_t*)&h); uv_run(uv_default_loop(), UV_RUN_DEFAULT); do_close(&h); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -188,7 +188,7 @@ TEST_IMPL(timer_ref2) { uv_unref((uv_handle_t*)&h); uv_run(uv_default_loop(), UV_RUN_DEFAULT); do_close(&h); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -203,7 +203,7 @@ TEST_IMPL(fs_event_ref) { uv_unref((uv_handle_t*)&h); uv_run(uv_default_loop(), UV_RUN_DEFAULT); do_close(&h); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -215,7 +215,7 @@ TEST_IMPL(fs_poll_ref) { uv_unref((uv_handle_t*)&h); uv_run(uv_default_loop(), UV_RUN_DEFAULT); do_close(&h); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -226,7 +226,7 @@ TEST_IMPL(tcp_ref) { uv_unref((uv_handle_t*)&h); uv_run(uv_default_loop(), UV_RUN_DEFAULT); do_close(&h); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -238,7 +238,7 @@ TEST_IMPL(tcp_ref2) { uv_unref((uv_handle_t*)&h); uv_run(uv_default_loop(), UV_RUN_DEFAULT); do_close(&h); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -250,8 +250,8 @@ TEST_IMPL(tcp_ref2b) { uv_unref((uv_handle_t*)&h); uv_close((uv_handle_t*)&h, close_cb); uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_EQ(1, close_cb_called); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + ASSERT(close_cb_called == 1); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -259,7 +259,7 @@ TEST_IMPL(tcp_ref2b) { TEST_IMPL(tcp_ref3) { struct sockaddr_in addr; uv_tcp_t h; - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); + ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); uv_tcp_init(uv_default_loop(), &h); uv_tcp_connect(&connect_req, &h, @@ -267,10 +267,10 @@ TEST_IMPL(tcp_ref3) { connect_and_shutdown); uv_unref((uv_handle_t*)&h); uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_EQ(1, connect_cb_called); - ASSERT_EQ(1, shutdown_cb_called); + ASSERT(connect_cb_called == 1); + ASSERT(shutdown_cb_called == 1); do_close(&h); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -278,7 +278,7 @@ TEST_IMPL(tcp_ref3) { TEST_IMPL(tcp_ref4) { struct sockaddr_in addr; uv_tcp_t h; - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); + ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); uv_tcp_init(uv_default_loop(), &h); uv_tcp_connect(&connect_req, &h, @@ -286,11 +286,11 @@ TEST_IMPL(tcp_ref4) { connect_and_write); uv_unref((uv_handle_t*)&h); uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_EQ(1, connect_cb_called); - ASSERT_EQ(1, write_cb_called); - ASSERT_EQ(1, shutdown_cb_called); + ASSERT(connect_cb_called == 1); + ASSERT(write_cb_called == 1); + ASSERT(shutdown_cb_called == 1); do_close(&h); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -301,7 +301,7 @@ TEST_IMPL(udp_ref) { uv_unref((uv_handle_t*)&h); uv_run(uv_default_loop(), UV_RUN_DEFAULT); do_close(&h); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -309,14 +309,14 @@ TEST_IMPL(udp_ref) { TEST_IMPL(udp_ref2) { struct sockaddr_in addr; uv_udp_t h; - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); + ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); uv_udp_init(uv_default_loop(), &h); uv_udp_bind(&h, (const struct sockaddr*) &addr, 0); uv_udp_recv_start(&h, (uv_alloc_cb)fail_cb, (uv_udp_recv_cb)fail_cb); uv_unref((uv_handle_t*)&h); uv_run(uv_default_loop(), UV_RUN_DEFAULT); do_close(&h); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -327,7 +327,7 @@ TEST_IMPL(udp_ref3) { uv_udp_send_t req; uv_udp_t h; - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); + ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); uv_udp_init(uv_default_loop(), &h); uv_udp_send(&req, &h, @@ -337,10 +337,10 @@ TEST_IMPL(udp_ref3) { (uv_udp_send_cb) req_cb); uv_unref((uv_handle_t*)&h); uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_EQ(1, req_cb_called); + ASSERT(req_cb_called == 1); do_close(&h); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -351,7 +351,7 @@ TEST_IMPL(pipe_ref) { uv_unref((uv_handle_t*)&h); uv_run(uv_default_loop(), UV_RUN_DEFAULT); do_close(&h); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -363,7 +363,7 @@ TEST_IMPL(pipe_ref2) { uv_unref((uv_handle_t*)&h); uv_run(uv_default_loop(), UV_RUN_DEFAULT); do_close(&h); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -374,10 +374,10 @@ TEST_IMPL(pipe_ref3) { uv_pipe_connect(&connect_req, &h, TEST_PIPENAME, connect_and_shutdown); uv_unref((uv_handle_t*)&h); uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_EQ(1, connect_cb_called); - ASSERT_EQ(1, shutdown_cb_called); + ASSERT(connect_cb_called == 1); + ASSERT(shutdown_cb_called == 1); do_close(&h); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -388,11 +388,11 @@ TEST_IMPL(pipe_ref4) { uv_pipe_connect(&connect_req, &h, TEST_PIPENAME, connect_and_write); uv_unref((uv_handle_t*)&h); uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_EQ(1, connect_cb_called); - ASSERT_EQ(1, write_cb_called); - ASSERT_EQ(1, shutdown_cb_called); + ASSERT(connect_cb_called == 1); + ASSERT(write_cb_called == 1); + ASSERT(shutdown_cb_called == 1); do_close(&h); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -410,7 +410,7 @@ TEST_IMPL(process_ref) { exepath_size = sizeof(exepath); r = uv_exepath(exepath, &exepath_size); - ASSERT_OK(r); + ASSERT(r == 0); argv[0] = exepath; options.file = exepath; @@ -418,17 +418,17 @@ TEST_IMPL(process_ref) { options.exit_cb = NULL; r = uv_spawn(uv_default_loop(), &h, &options); - ASSERT_OK(r); + ASSERT(r == 0); uv_unref((uv_handle_t*)&h); uv_run(uv_default_loop(), UV_RUN_DEFAULT); r = uv_process_kill(&h, /* SIGTERM */ 15); - ASSERT_OK(r); + ASSERT(r == 0); do_close(&h); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -437,9 +437,9 @@ TEST_IMPL(has_ref) { uv_idle_t h; uv_idle_init(uv_default_loop(), &h); uv_ref((uv_handle_t*)&h); - ASSERT_EQ(1, uv_has_ref((uv_handle_t*)&h)); + ASSERT(uv_has_ref((uv_handle_t*)&h) == 1); uv_unref((uv_handle_t*)&h); - ASSERT_OK(uv_has_ref((uv_handle_t*)&h)); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + ASSERT(uv_has_ref((uv_handle_t*)&h) == 0); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-run-nowait.c b/test/test-run-nowait.c index 89f5f55..43524f6 100644 --- a/test/test-run-nowait.c +++ b/test/test-run-nowait.c @@ -27,7 +27,7 @@ static int timer_called = 0; static void timer_cb(uv_timer_t* handle) { - ASSERT_PTR_EQ(handle, &timer_handle); + ASSERT(handle == &timer_handle); timer_called = 1; } @@ -38,9 +38,8 @@ TEST_IMPL(run_nowait) { uv_timer_start(&timer_handle, timer_cb, 100, 100); r = uv_run(uv_default_loop(), UV_RUN_NOWAIT); - ASSERT(r); - ASSERT_OK(timer_called); + ASSERT(r != 0); + ASSERT(timer_called == 0); - MAKE_VALGRIND_HAPPY(uv_default_loop()); return 0; } diff --git a/test/test-run-once.c b/test/test-run-once.c index 0ae0082..10cbf95 100644 --- a/test/test-run-once.c +++ b/test/test-run-once.c @@ -29,7 +29,7 @@ static int idle_counter; static void idle_cb(uv_idle_t* handle) { - ASSERT_PTR_EQ(handle, &idle_handle); + ASSERT(handle == &idle_handle); if (++idle_counter == NUM_TICKS) uv_idle_stop(handle); @@ -41,8 +41,8 @@ TEST_IMPL(run_once) { uv_idle_start(&idle_handle, idle_cb); while (uv_run(uv_default_loop(), UV_RUN_ONCE)); - ASSERT_EQ(idle_counter, NUM_TICKS); + ASSERT(idle_counter == NUM_TICKS); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-semaphore.c b/test/test-semaphore.c index ad54808..ac03bb0 100644 --- a/test/test-semaphore.c +++ b/test/test-semaphore.c @@ -40,7 +40,7 @@ static void worker(void* arg) { uv_sleep(c->delay); uv_mutex_lock(&c->mutex); - ASSERT_OK(c->posted); + ASSERT(c->posted == 0); uv_sem_post(&c->sem); c->posted = 1; uv_mutex_unlock(&c->mutex); @@ -53,17 +53,17 @@ TEST_IMPL(semaphore_1) { memset(&wc, 0, sizeof(wc)); - ASSERT_OK(uv_sem_init(&wc.sem, 0)); - ASSERT_OK(uv_mutex_init(&wc.mutex)); - ASSERT_OK(uv_thread_create(&thread, worker, &wc)); + ASSERT(0 == uv_sem_init(&wc.sem, 0)); + ASSERT(0 == uv_mutex_init(&wc.mutex)); + ASSERT(0 == uv_thread_create(&thread, worker, &wc)); uv_sleep(100); uv_mutex_lock(&wc.mutex); - ASSERT_EQ(1, wc.posted); + ASSERT(wc.posted == 1); uv_sem_wait(&wc.sem); /* should not block */ uv_mutex_unlock(&wc.mutex); /* ergo, it should be ok to unlock after wait */ - ASSERT_OK(uv_thread_join(&thread)); + ASSERT(0 == uv_thread_join(&thread)); uv_mutex_destroy(&wc.mutex); uv_sem_destroy(&wc.sem); @@ -78,13 +78,13 @@ TEST_IMPL(semaphore_2) { memset(&wc, 0, sizeof(wc)); wc.delay = 100; - ASSERT_OK(uv_sem_init(&wc.sem, 0)); - ASSERT_OK(uv_mutex_init(&wc.mutex)); - ASSERT_OK(uv_thread_create(&thread, worker, &wc)); + ASSERT(0 == uv_sem_init(&wc.sem, 0)); + ASSERT(0 == uv_mutex_init(&wc.mutex)); + ASSERT(0 == uv_thread_create(&thread, worker, &wc)); uv_sem_wait(&wc.sem); - ASSERT_OK(uv_thread_join(&thread)); + ASSERT(0 == uv_thread_join(&thread)); uv_mutex_destroy(&wc.mutex); uv_sem_destroy(&wc.sem); @@ -95,15 +95,15 @@ TEST_IMPL(semaphore_2) { TEST_IMPL(semaphore_3) { uv_sem_t sem; - ASSERT_OK(uv_sem_init(&sem, 3)); + ASSERT(0 == uv_sem_init(&sem, 3)); uv_sem_wait(&sem); /* should not block */ uv_sem_wait(&sem); /* should not block */ - ASSERT_OK(uv_sem_trywait(&sem)); - ASSERT_EQ(UV_EAGAIN, uv_sem_trywait(&sem)); + ASSERT(0 == uv_sem_trywait(&sem)); + ASSERT(UV_EAGAIN == uv_sem_trywait(&sem)); uv_sem_post(&sem); - ASSERT_OK(uv_sem_trywait(&sem)); - ASSERT_EQ(UV_EAGAIN, uv_sem_trywait(&sem)); + ASSERT(0 == uv_sem_trywait(&sem)); + ASSERT(UV_EAGAIN == uv_sem_trywait(&sem)); uv_sem_destroy(&sem); diff --git a/test/test-shutdown-close.c b/test/test-shutdown-close.c index 306404a..78c369b 100644 --- a/test/test-shutdown-close.c +++ b/test/test-shutdown-close.c @@ -37,7 +37,7 @@ static int close_cb_called = 0; static void shutdown_cb(uv_shutdown_t* req, int status) { - ASSERT_PTR_EQ(req, &shutdown_req); + ASSERT(req == &shutdown_req); ASSERT(status == 0 || status == UV_ECANCELED); shutdown_cb_called++; } @@ -51,14 +51,14 @@ static void close_cb(uv_handle_t* handle) { static void connect_cb(uv_connect_t* req, int status) { int r; - ASSERT_PTR_EQ(req, &connect_req); - ASSERT_OK(status); + ASSERT(req == &connect_req); + ASSERT(status == 0); r = uv_shutdown(&shutdown_req, req->handle, shutdown_cb); - ASSERT_OK(r); - ASSERT_OK(uv_is_closing((uv_handle_t*) req->handle)); + ASSERT(r == 0); + ASSERT(0 == uv_is_closing((uv_handle_t*) req->handle)); uv_close((uv_handle_t*) req->handle, close_cb); - ASSERT_EQ(1, uv_is_closing((uv_handle_t*) req->handle)); + ASSERT(1 == uv_is_closing((uv_handle_t*) req->handle)); connect_cb_called++; } @@ -69,22 +69,22 @@ TEST_IMPL(shutdown_close_tcp) { uv_tcp_t h; int r; - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); + ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); r = uv_tcp_init(uv_default_loop(), &h); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_tcp_connect(&connect_req, &h, (const struct sockaddr*) &addr, connect_cb); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_EQ(1, connect_cb_called); - ASSERT_EQ(1, shutdown_cb_called); - ASSERT_EQ(1, close_cb_called); + ASSERT(connect_cb_called == 1); + ASSERT(shutdown_cb_called == 1); + ASSERT(close_cb_called == 1); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -94,15 +94,15 @@ TEST_IMPL(shutdown_close_pipe) { int r; r = uv_pipe_init(uv_default_loop(), &h, 0); - ASSERT_OK(r); + ASSERT(r == 0); uv_pipe_connect(&connect_req, &h, TEST_PIPENAME, connect_cb); r = uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_EQ(1, connect_cb_called); - ASSERT_EQ(1, shutdown_cb_called); - ASSERT_EQ(1, close_cb_called); + ASSERT(connect_cb_called == 1); + ASSERT(shutdown_cb_called == 1); + ASSERT(close_cb_called == 1); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-shutdown-eof.c b/test/test-shutdown-eof.c index 6669c29..0abab91 100644 --- a/test/test-shutdown-eof.c +++ b/test/test-shutdown-eof.c @@ -46,7 +46,7 @@ static void alloc_cb(uv_handle_t* handle, size_t size, uv_buf_t* buf) { static void read_cb(uv_stream_t* t, ssize_t nread, const uv_buf_t* buf) { - ASSERT_PTR_EQ((uv_tcp_t*)t, &tcp); + ASSERT((uv_tcp_t*)t == &tcp); if (nread == 0) { free(buf->base); @@ -54,14 +54,14 @@ static void read_cb(uv_stream_t* t, ssize_t nread, const uv_buf_t* buf) { } if (!got_q) { - ASSERT_EQ(1, nread); + ASSERT(nread == 1); ASSERT(!got_eof); - ASSERT_EQ(buf->base[0], 'Q'); + ASSERT(buf->base[0] == 'Q'); free(buf->base); got_q = 1; puts("got Q"); } else { - ASSERT_EQ(nread, UV_EOF); + ASSERT(nread == UV_EOF); if (buf->base) { free(buf->base); } @@ -72,24 +72,24 @@ static void read_cb(uv_stream_t* t, ssize_t nread, const uv_buf_t* buf) { static void shutdown_cb(uv_shutdown_t *req, int status) { - ASSERT_PTR_EQ(req, &shutdown_req); + ASSERT(req == &shutdown_req); - ASSERT_EQ(1, called_connect_cb); + ASSERT(called_connect_cb == 1); ASSERT(!got_eof); - ASSERT_OK(called_tcp_close_cb); - ASSERT_OK(called_timer_close_cb); - ASSERT_OK(called_timer_cb); + ASSERT(called_tcp_close_cb == 0); + ASSERT(called_timer_close_cb == 0); + ASSERT(called_timer_cb == 0); called_shutdown_cb++; } static void connect_cb(uv_connect_t *req, int status) { - ASSERT_OK(status); - ASSERT_PTR_EQ(req, &connect_req); + ASSERT(status == 0); + ASSERT(req == &connect_req); /* Start reading from our connection so we can receive the EOF. */ - ASSERT_OK(uv_read_start((uv_stream_t*)&tcp, alloc_cb, read_cb)); + ASSERT_EQ(0, uv_read_start((uv_stream_t*)&tcp, alloc_cb, read_cb)); /* Check error handling. */ ASSERT_EQ(UV_EALREADY, uv_read_start((uv_stream_t*)&tcp, alloc_cb, read_cb)); @@ -107,37 +107,37 @@ static void connect_cb(uv_connect_t *req, int status) { uv_shutdown(&shutdown_req, (uv_stream_t*) &tcp, shutdown_cb); called_connect_cb++; - ASSERT_OK(called_shutdown_cb); + ASSERT(called_shutdown_cb == 0); } static void tcp_close_cb(uv_handle_t* handle) { - ASSERT_PTR_EQ(handle, (uv_handle_t*) &tcp); + ASSERT(handle == (uv_handle_t*) &tcp); - ASSERT_EQ(1, called_connect_cb); + ASSERT(called_connect_cb == 1); ASSERT(got_q); ASSERT(got_eof); - ASSERT_EQ(1, called_timer_cb); + ASSERT(called_timer_cb == 1); called_tcp_close_cb++; } static void timer_close_cb(uv_handle_t* handle) { - ASSERT_PTR_EQ(handle, (uv_handle_t*) &timer); + ASSERT(handle == (uv_handle_t*) &timer); called_timer_close_cb++; } static void timer_cb(uv_timer_t* handle) { - ASSERT_PTR_EQ(handle, &timer); + ASSERT(handle == &timer); uv_close((uv_handle_t*) handle, timer_close_cb); /* * The most important assert of the test: we have not received * tcp_close_cb yet. */ - ASSERT_OK(called_tcp_close_cb); + ASSERT(called_tcp_close_cb == 0); uv_close((uv_handle_t*) &tcp, tcp_close_cb); called_timer_cb++; @@ -158,11 +158,11 @@ TEST_IMPL(shutdown_eof) { qbuf.len = 1; r = uv_timer_init(uv_default_loop(), &timer); - ASSERT_OK(r); + ASSERT(r == 0); uv_timer_start(&timer, timer_cb, 100, 0); - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &server_addr)); + ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &server_addr)); r = uv_tcp_init(uv_default_loop(), &tcp); ASSERT(!r); @@ -174,15 +174,15 @@ TEST_IMPL(shutdown_eof) { uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_EQ(1, called_connect_cb); - ASSERT_EQ(1, called_shutdown_cb); + ASSERT(called_connect_cb == 1); + ASSERT(called_shutdown_cb == 1); ASSERT(got_eof); ASSERT(got_q); - ASSERT_EQ(1, called_tcp_close_cb); - ASSERT_EQ(1, called_timer_close_cb); - ASSERT_EQ(1, called_timer_cb); + ASSERT(called_tcp_close_cb == 1); + ASSERT(called_timer_close_cb == 1); + ASSERT(called_timer_cb == 1); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-shutdown-simultaneous.c b/test/test-shutdown-simultaneous.c index 0dd8e35..7de3bd4 100644 --- a/test/test-shutdown-simultaneous.c +++ b/test/test-shutdown-simultaneous.c @@ -44,8 +44,8 @@ static void alloc_cb(uv_handle_t* handle, size_t size, uv_buf_t* buf) { static void shutdown_cb(uv_shutdown_t *req, int status) { ASSERT_PTR_EQ(req, &shutdown_req); - ASSERT_EQ(1, called_connect_cb); - ASSERT_OK(called_tcp_close_cb); + ASSERT_EQ(called_connect_cb, 1); + ASSERT_EQ(called_tcp_close_cb, 0); } @@ -58,8 +58,8 @@ static void read_cb(uv_stream_t* t, ssize_t nread, const uv_buf_t* buf) { } if (!got_q) { - ASSERT_EQ(4, nread); - ASSERT_OK(got_eof); + ASSERT_EQ(nread, 4); + ASSERT_EQ(got_eof, 0); ASSERT_MEM_EQ(buf->base, "QQSS", 4); free(buf->base); got_q = 1; @@ -79,11 +79,11 @@ static void read_cb(uv_stream_t* t, ssize_t nread, const uv_buf_t* buf) { static void connect_cb(uv_connect_t *req, int status) { - ASSERT_OK(status); + ASSERT_EQ(status, 0); ASSERT_PTR_EQ(req, &connect_req); /* Start reading from our connection so we can receive the EOF. */ - ASSERT_OK(uv_read_start((uv_stream_t*)&tcp, alloc_cb, read_cb)); + ASSERT_EQ(0, uv_read_start((uv_stream_t*)&tcp, alloc_cb, read_cb)); /* Check error handling. */ ASSERT_EQ(UV_EALREADY, uv_read_start((uv_stream_t*)&tcp, alloc_cb, read_cb)); @@ -98,7 +98,7 @@ static void connect_cb(uv_connect_t *req, int status) { ASSERT_EQ(qbuf.len, uv_try_write((uv_stream_t*) &tcp, &qbuf, 1)); called_connect_cb++; - ASSERT_OK(called_shutdown_cb); + ASSERT_EQ(called_shutdown_cb, 0); } @@ -113,23 +113,23 @@ TEST_IMPL(shutdown_simultaneous) { qbuf.base = "QQSS"; qbuf.len = 4; - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &server_addr)); + ASSERT_EQ(0, uv_ip4_addr("127.0.0.1", TEST_PORT, &server_addr)); r = uv_tcp_init(uv_default_loop(), &tcp); - ASSERT_OK(r); + ASSERT_EQ(r, 0); r = uv_tcp_connect(&connect_req, &tcp, (const struct sockaddr*) &server_addr, connect_cb); - ASSERT_OK(r); + ASSERT_EQ(r, 0); uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_EQ(1, called_connect_cb); - ASSERT_EQ(1, called_shutdown_cb); - ASSERT_EQ(1, got_eof); - ASSERT_EQ(1, got_q); + ASSERT_EQ(called_connect_cb, 1); + ASSERT_EQ(called_shutdown_cb, 1); + ASSERT_EQ(got_eof, 1); + ASSERT_EQ(got_q, 1); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-shutdown-twice.c b/test/test-shutdown-twice.c index c21a983..d7aae89 100644 --- a/test/test-shutdown-twice.c +++ b/test/test-shutdown-twice.c @@ -37,8 +37,8 @@ static void close_cb(uv_handle_t* handle) { } static void shutdown_cb(uv_shutdown_t* req, int status) { - ASSERT_PTR_EQ(req, &req1); - ASSERT_OK(status); + ASSERT(req == &req1); + ASSERT(status == 0); shutdown_cb_called++; uv_close((uv_handle_t*) req->handle, close_cb); } @@ -46,12 +46,12 @@ static void shutdown_cb(uv_shutdown_t* req, int status) { static void connect_cb(uv_connect_t* req, int status) { int r; - ASSERT_OK(status); + ASSERT(status == 0); r = uv_shutdown(&req1, req->handle, shutdown_cb); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_shutdown(&req2, req->handle, shutdown_cb); - ASSERT(r); + ASSERT(r != 0); } @@ -63,23 +63,23 @@ TEST_IMPL(shutdown_twice) { uv_connect_t connect_req; - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); + ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); loop = uv_default_loop(); r = uv_tcp_init(loop, &h); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_tcp_connect(&connect_req, &h, (const struct sockaddr*) &addr, connect_cb); - ASSERT_OK(r); + ASSERT(r == 0); - r = uv_run(loop, UV_RUN_DEFAULT); - ASSERT_OK(r); + r = uv_run(uv_default_loop(), UV_RUN_DEFAULT); + ASSERT(r == 0); - ASSERT_EQ(1, shutdown_cb_called); + ASSERT(shutdown_cb_called == 1); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-signal-multiple-loops.c b/test/test-signal-multiple-loops.c index e68eabf..7d61ff6 100644 --- a/test/test-signal-multiple-loops.c +++ b/test/test-signal-multiple-loops.c @@ -50,30 +50,30 @@ enum signal_action { }; static uv_sem_t sem; -static uv_mutex_t lock; -static int stop = 0; +static uv_mutex_t counter_lock; +static volatile int stop = 0; -static int signal1_cb_counter = 0; -static int signal2_cb_counter = 0; -static int loop_creation_counter = 0; +static volatile int signal1_cb_counter = 0; +static volatile int signal2_cb_counter = 0; +static volatile int loop_creation_counter = 0; -static void increment_counter(int* counter) { - uv_mutex_lock(&lock); +static void increment_counter(volatile int* counter) { + uv_mutex_lock(&counter_lock); ++(*counter); - uv_mutex_unlock(&lock); + uv_mutex_unlock(&counter_lock); } static void signal1_cb(uv_signal_t* handle, int signum) { - ASSERT_EQ(signum, SIGUSR1); + ASSERT(signum == SIGUSR1); increment_counter(&signal1_cb_counter); uv_signal_stop(handle); } static void signal2_cb(uv_signal_t* handle, int signum) { - ASSERT_EQ(signum, SIGUSR2); + ASSERT(signum == SIGUSR2); increment_counter(&signal2_cb_counter); uv_signal_stop(handle); } @@ -89,25 +89,25 @@ static void signal_handling_worker(void* context) { action = (enum signal_action) (uintptr_t) context; - ASSERT_OK(uv_loop_init(&loop)); + ASSERT(0 == uv_loop_init(&loop)); /* Setup the signal watchers and start them. */ if (action == ONLY_SIGUSR1 || action == SIGUSR1_AND_SIGUSR2) { r = uv_signal_init(&loop, &signal1a); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_signal_start(&signal1a, signal1_cb, SIGUSR1); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_signal_init(&loop, &signal1b); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_signal_start(&signal1b, signal1_cb, SIGUSR1); - ASSERT_OK(r); + ASSERT(r == 0); } if (action == ONLY_SIGUSR2 || action == SIGUSR1_AND_SIGUSR2) { r = uv_signal_init(&loop, &signal2); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_signal_start(&signal2, signal2_cb, SIGUSR2); - ASSERT_OK(r); + ASSERT(r == 0); } /* Signal watchers are now set up. */ @@ -117,26 +117,26 @@ static void signal_handling_worker(void* context) { * will return when all signal watchers caught a signal. */ r = uv_run(&loop, UV_RUN_DEFAULT); - ASSERT_OK(r); + ASSERT(r == 0); /* Restart the signal watchers. */ if (action == ONLY_SIGUSR1 || action == SIGUSR1_AND_SIGUSR2) { r = uv_signal_start(&signal1a, signal1_cb, SIGUSR1); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_signal_start(&signal1b, signal1_cb, SIGUSR1); - ASSERT_OK(r); + ASSERT(r == 0); } if (action == ONLY_SIGUSR2 || action == SIGUSR1_AND_SIGUSR2) { r = uv_signal_start(&signal2, signal2_cb, SIGUSR2); - ASSERT_OK(r); + ASSERT(r == 0); } /* Wait for signals once more. */ uv_sem_post(&sem); r = uv_run(&loop, UV_RUN_DEFAULT); - ASSERT_OK(r); + ASSERT(r == 0); /* Close the watchers. */ if (action == ONLY_SIGUSR1 || action == SIGUSR1_AND_SIGUSR2) { @@ -150,7 +150,7 @@ static void signal_handling_worker(void* context) { /* Wait for the signal watchers to close. */ r = uv_run(&loop, UV_RUN_DEFAULT); - ASSERT_OK(r); + ASSERT(r == 0); uv_loop_close(&loop); } @@ -162,8 +162,6 @@ static void signal_unexpected_cb(uv_signal_t* handle, int signum) { static void loop_creating_worker(void* context) { - int done; - (void) context; do { @@ -173,28 +171,24 @@ static void loop_creating_worker(void* context) { loop = malloc(sizeof(*loop)); ASSERT_NOT_NULL(loop); - ASSERT_OK(uv_loop_init(loop)); + ASSERT(0 == uv_loop_init(loop)); r = uv_signal_init(loop, &signal); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_signal_start(&signal, signal_unexpected_cb, SIGTERM); - ASSERT_OK(r); + ASSERT(r == 0); uv_close((uv_handle_t*) &signal, NULL); r = uv_run(loop, UV_RUN_DEFAULT); - ASSERT_OK(r); + ASSERT(r == 0); uv_loop_close(loop); free(loop); increment_counter(&loop_creation_counter); - - uv_mutex_lock(&lock); - done = stop; - uv_mutex_unlock(&lock); - } while (!done); + } while (!stop); } @@ -208,18 +202,8 @@ TEST_IMPL(signal_multiple_loops) { #endif /* TODO(gengjiawen): Fix test on QEMU. */ #if defined(__QEMU__) - /* See https://github.com/libuv/libuv/issues/2859 */ + // See https://github.com/libuv/libuv/issues/2859 RETURN_SKIP("QEMU's signal emulation code is notoriously tricky"); -#endif -#if defined(__ASAN__) || defined(__MSAN__) - /* See https://github.com/libuv/libuv/issues/3956 */ - RETURN_SKIP("Test is too slow to run under ASan or MSan"); -#endif -#if defined(__TSAN__) - /* ThreadSanitizer complains - likely legitimately - about data races - * in uv__signal_compare() in src/unix/signal.c but that's pre-existing. - */ - RETURN_SKIP("Fix test under ThreadSanitizer"); #endif uv_thread_t loop_creating_threads[NUM_LOOP_CREATING_THREADS]; uv_thread_t signal_handling_threads[NUM_SIGNAL_HANDLING_THREADS]; @@ -229,17 +213,17 @@ TEST_IMPL(signal_multiple_loops) { int r; r = uv_sem_init(&sem, 0); - ASSERT_OK(r); + ASSERT(r == 0); - r = uv_mutex_init(&lock); - ASSERT_OK(r); + r = uv_mutex_init(&counter_lock); + ASSERT(r == 0); /* Create a couple of threads that create a destroy loops continuously. */ for (i = 0; i < NUM_LOOP_CREATING_THREADS; i++) { r = uv_thread_create(&loop_creating_threads[i], loop_creating_worker, NULL); - ASSERT_OK(r); + ASSERT(r == 0); } /* Create a couple of threads that actually handle signals. */ @@ -253,7 +237,7 @@ TEST_IMPL(signal_multiple_loops) { r = uv_thread_create(&signal_handling_threads[i], signal_handling_worker, (void*) (uintptr_t) action); - ASSERT_OK(r); + ASSERT(r == 0); } /* Wait until all threads have started and set up their signal watchers. */ @@ -261,9 +245,9 @@ TEST_IMPL(signal_multiple_loops) { uv_sem_wait(&sem); r = kill(getpid(), SIGUSR1); - ASSERT_OK(r); + ASSERT(r == 0); r = kill(getpid(), SIGUSR2); - ASSERT_OK(r); + ASSERT(r == 0); /* Wait for all threads to handle these signals. */ for (i = 0; i < NUM_SIGNAL_HANDLING_THREADS; i++) @@ -277,25 +261,23 @@ TEST_IMPL(signal_multiple_loops) { pthread_sigmask(SIG_SETMASK, &sigset, NULL); r = kill(getpid(), SIGUSR1); - ASSERT_OK(r); + ASSERT(r == 0); r = kill(getpid(), SIGUSR2); - ASSERT_OK(r); + ASSERT(r == 0); /* Wait for all signal handling threads to exit. */ for (i = 0; i < NUM_SIGNAL_HANDLING_THREADS; i++) { r = uv_thread_join(&signal_handling_threads[i]); - ASSERT_OK(r); + ASSERT(r == 0); } /* Tell all loop creating threads to stop. */ - uv_mutex_lock(&lock); stop = 1; - uv_mutex_unlock(&lock); /* Wait for all loop creating threads to exit. */ for (i = 0; i < NUM_LOOP_CREATING_THREADS; i++) { r = uv_thread_join(&loop_creating_threads[i]); - ASSERT_OK(r); + ASSERT(r == 0); } uv_sem_destroy(&sem); @@ -306,15 +288,15 @@ TEST_IMPL(signal_multiple_loops) { /* The division by three reflects the fact that we spawn three different * thread groups of (NUM_SIGNAL_HANDLING_THREADS / 3) threads each. */ - ASSERT_EQ(signal1_cb_counter, 8 * (NUM_SIGNAL_HANDLING_THREADS / 3)); - ASSERT_EQ(signal2_cb_counter, 4 * (NUM_SIGNAL_HANDLING_THREADS / 3)); + ASSERT(signal1_cb_counter == 8 * (NUM_SIGNAL_HANDLING_THREADS / 3)); + ASSERT(signal2_cb_counter == 4 * (NUM_SIGNAL_HANDLING_THREADS / 3)); /* We don't know exactly how much loops will be created and destroyed, but at * least there should be 1 for every loop creating thread. */ - ASSERT_GE(loop_creation_counter, NUM_LOOP_CREATING_THREADS); + ASSERT(loop_creation_counter >= NUM_LOOP_CREATING_THREADS); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-signal-pending-on-close.c b/test/test-signal-pending-on-close.c index 42a4296..428a97e 100644 --- a/test/test-signal-pending-on-close.c +++ b/test/test-signal-pending-on-close.c @@ -35,7 +35,7 @@ static int close_cb_called; static void stop_loop_cb(uv_signal_t* signal, int signum) { - ASSERT_EQ(signum, SIGPIPE); + ASSERT(signum == SIGPIPE); uv_stop(signal->loop); } @@ -50,7 +50,7 @@ static void close_cb(uv_handle_t *handle) { static void write_cb(uv_write_t* req, int status) { ASSERT_NOT_NULL(req); - ASSERT_EQ(status, UV_EPIPE); + ASSERT(status == UV_EPIPE); free(buf); uv_close((uv_handle_t *) &pipe_hdl, close_cb); uv_close((uv_handle_t *) &signal_hdl, close_cb); @@ -62,17 +62,17 @@ TEST_IMPL(signal_pending_on_close) { uv_buf_t buffer; int r; - ASSERT_OK(uv_loop_init(&loop)); + ASSERT(0 == uv_loop_init(&loop)); - ASSERT_OK(uv_signal_init(&loop, &signal_hdl)); + ASSERT(0 == uv_signal_init(&loop, &signal_hdl)); - ASSERT_OK(uv_signal_start(&signal_hdl, signal_cb, SIGPIPE)); + ASSERT(0 == uv_signal_start(&signal_hdl, signal_cb, SIGPIPE)); - ASSERT_OK(pipe(pipefds)); + ASSERT(0 == pipe(pipefds)); - ASSERT_OK(uv_pipe_init(&loop, &pipe_hdl, 0)); + ASSERT(0 == uv_pipe_init(&loop, &pipe_hdl, 0)); - ASSERT_OK(uv_pipe_open(&pipe_hdl, pipefds[1])); + ASSERT(0 == uv_pipe_open(&pipe_hdl, pipefds[1])); /* Write data large enough so it needs loop iteration */ buf = malloc(1<<24); @@ -81,35 +81,38 @@ TEST_IMPL(signal_pending_on_close) { buffer = uv_buf_init(buf, 1<<24); r = uv_write(&write_req, (uv_stream_t *) &pipe_hdl, &buffer, 1, write_cb); - ASSERT_OK(r); + ASSERT(0 == r); /* cause a SIGPIPE on write in next iteration */ close(pipefds[0]); - ASSERT_OK(uv_run(&loop, UV_RUN_DEFAULT)); + ASSERT(0 == uv_run(&loop, UV_RUN_DEFAULT)); - ASSERT_EQ(2, close_cb_called); + ASSERT(0 == uv_loop_close(&loop)); - MAKE_VALGRIND_HAPPY(&loop); + ASSERT(2 == close_cb_called); + + MAKE_VALGRIND_HAPPY(); return 0; } TEST_IMPL(signal_close_loop_alive) { - ASSERT_OK(uv_loop_init(&loop)); - ASSERT_OK(uv_signal_init(&loop, &signal_hdl)); - ASSERT_OK(uv_signal_start(&signal_hdl, stop_loop_cb, SIGPIPE)); + ASSERT(0 == uv_loop_init(&loop)); + ASSERT(0 == uv_signal_init(&loop, &signal_hdl)); + ASSERT(0 == uv_signal_start(&signal_hdl, stop_loop_cb, SIGPIPE)); uv_unref((uv_handle_t*) &signal_hdl); - ASSERT_OK(uv_kill(uv_os_getpid(), SIGPIPE)); - ASSERT_OK(uv_run(&loop, UV_RUN_DEFAULT)); + ASSERT(0 == uv_kill(uv_os_getpid(), SIGPIPE)); + ASSERT(0 == uv_run(&loop, UV_RUN_DEFAULT)); uv_close((uv_handle_t*) &signal_hdl, close_cb); - ASSERT_EQ(1, uv_loop_alive(&loop)); + ASSERT(1 == uv_loop_alive(&loop)); - ASSERT_OK(uv_run(&loop, UV_RUN_DEFAULT)); - ASSERT_EQ(1, close_cb_called); + ASSERT(0 == uv_run(&loop, UV_RUN_DEFAULT)); + ASSERT(0 == uv_loop_close(&loop)); + ASSERT(1 == close_cb_called); - MAKE_VALGRIND_HAPPY(&loop); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-signal.c b/test/test-signal.c index b1e24bb..c2ce5ec 100644 --- a/test/test-signal.c +++ b/test/test-signal.c @@ -31,14 +31,14 @@ TEST_IMPL(kill_invalid_signum) { pid = uv_os_getpid(); - ASSERT_EQ(uv_kill(pid, -1), UV_EINVAL); + ASSERT(uv_kill(pid, -1) == UV_EINVAL); #ifdef _WIN32 /* NSIG is not available on all platforms. */ - ASSERT_EQ(uv_kill(pid, NSIG), UV_EINVAL); + ASSERT(uv_kill(pid, NSIG) == UV_EINVAL); #endif - ASSERT_EQ(uv_kill(pid, 4096), UV_EINVAL); + ASSERT(uv_kill(pid, 4096) == UV_EINVAL); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -55,21 +55,21 @@ TEST_IMPL(win32_signum_number) { loop = uv_default_loop(); uv_signal_init(loop, &signal); - ASSERT_EQ(uv_signal_start(&signal, signum_test_cb, 0), UV_EINVAL); - ASSERT_OK(uv_signal_start(&signal, signum_test_cb, SIGINT)); - ASSERT_OK(uv_signal_start(&signal, signum_test_cb, SIGBREAK)); - ASSERT_OK(uv_signal_start(&signal, signum_test_cb, SIGHUP)); - ASSERT_OK(uv_signal_start(&signal, signum_test_cb, SIGWINCH)); - ASSERT_OK(uv_signal_start(&signal, signum_test_cb, SIGILL)); - ASSERT_OK(uv_signal_start(&signal, signum_test_cb, SIGABRT_COMPAT)); - ASSERT_OK(uv_signal_start(&signal, signum_test_cb, SIGFPE)); - ASSERT_OK(uv_signal_start(&signal, signum_test_cb, SIGSEGV)); - ASSERT_OK(uv_signal_start(&signal, signum_test_cb, SIGTERM)); - ASSERT_OK(uv_signal_start(&signal, signum_test_cb, SIGABRT)); - ASSERT_EQ(uv_signal_start(&signal, signum_test_cb, -1), UV_EINVAL); - ASSERT_EQ(uv_signal_start(&signal, signum_test_cb, NSIG), UV_EINVAL); - ASSERT_EQ(uv_signal_start(&signal, signum_test_cb, 1024), UV_EINVAL); - MAKE_VALGRIND_HAPPY(loop); + ASSERT(uv_signal_start(&signal, signum_test_cb, 0) == UV_EINVAL); + ASSERT(uv_signal_start(&signal, signum_test_cb, SIGINT) == 0); + ASSERT(uv_signal_start(&signal, signum_test_cb, SIGBREAK) == 0); + ASSERT(uv_signal_start(&signal, signum_test_cb, SIGHUP) == 0); + ASSERT(uv_signal_start(&signal, signum_test_cb, SIGWINCH) == 0); + ASSERT(uv_signal_start(&signal, signum_test_cb, SIGILL) == 0); + ASSERT(uv_signal_start(&signal, signum_test_cb, SIGABRT_COMPAT) == 0); + ASSERT(uv_signal_start(&signal, signum_test_cb, SIGFPE) == 0); + ASSERT(uv_signal_start(&signal, signum_test_cb, SIGSEGV) == 0); + ASSERT(uv_signal_start(&signal, signum_test_cb, SIGTERM) == 0); + ASSERT(uv_signal_start(&signal, signum_test_cb, SIGABRT) == 0); + ASSERT(uv_signal_start(&signal, signum_test_cb, -1) == UV_EINVAL); + ASSERT(uv_signal_start(&signal, signum_test_cb, NSIG) == UV_EINVAL); + ASSERT(uv_signal_start(&signal, signum_test_cb, 1024) == UV_EINVAL); + MAKE_VALGRIND_HAPPY(); return 0; } #else @@ -100,7 +100,7 @@ struct signal_ctx { static void signal_cb(uv_signal_t* handle, int signum) { struct signal_ctx* ctx = container_of(handle, struct signal_ctx, handle); - ASSERT_EQ(signum, ctx->signum); + ASSERT(signum == ctx->signum); if (++ctx->ncalls == NSIGNALS) { if (ctx->stop_or_close == STOP) uv_signal_stop(handle); @@ -113,8 +113,8 @@ static void signal_cb(uv_signal_t* handle, int signum) { static void signal_cb_one_shot(uv_signal_t* handle, int signum) { struct signal_ctx* ctx = container_of(handle, struct signal_ctx, handle); - ASSERT_EQ(signum, ctx->signum); - ASSERT_EQ(1, ++ctx->ncalls); + ASSERT(signum == ctx->signum); + ASSERT(++ctx->ncalls == 1); if (ctx->stop_or_close == CLOSE) uv_close((uv_handle_t*)handle, NULL); } @@ -138,18 +138,18 @@ static void start_watcher(uv_loop_t* loop, ctx->signum = signum; ctx->stop_or_close = CLOSE; ctx->one_shot = one_shot; - ASSERT_OK(uv_signal_init(loop, &ctx->handle)); + ASSERT(0 == uv_signal_init(loop, &ctx->handle)); if (one_shot) - ASSERT_OK(uv_signal_start_oneshot(&ctx->handle, signal_cb_one_shot, signum)); + ASSERT(0 == uv_signal_start_oneshot(&ctx->handle, signal_cb_one_shot, signum)); else - ASSERT_OK(uv_signal_start(&ctx->handle, signal_cb, signum)); + ASSERT(0 == uv_signal_start(&ctx->handle, signal_cb, signum)); } static void start_timer(uv_loop_t* loop, int signum, struct timer_ctx* ctx) { ctx->ncalls = 0; ctx->signum = signum; - ASSERT_OK(uv_timer_init(loop, &ctx->handle)); - ASSERT_OK(uv_timer_start(&ctx->handle, timer_cb, 5, 5)); + ASSERT(0 == uv_timer_init(loop, &ctx->handle)); + ASSERT(0 == uv_timer_start(&ctx->handle, timer_cb, 5, 5)); } @@ -162,25 +162,25 @@ TEST_IMPL(we_get_signal) { start_timer(loop, SIGCHLD, &tc); start_watcher(loop, SIGCHLD, &sc, 0); sc.stop_or_close = STOP; /* stop, don't close the signal handle */ - ASSERT_OK(uv_run(loop, UV_RUN_DEFAULT)); - ASSERT_EQ(tc.ncalls, NSIGNALS); - ASSERT_EQ(sc.ncalls, NSIGNALS); + ASSERT(0 == uv_run(loop, UV_RUN_DEFAULT)); + ASSERT(tc.ncalls == NSIGNALS); + ASSERT(sc.ncalls == NSIGNALS); start_timer(loop, SIGCHLD, &tc); - ASSERT_OK(uv_run(loop, UV_RUN_DEFAULT)); - ASSERT_EQ(tc.ncalls, NSIGNALS); - ASSERT_EQ(sc.ncalls, NSIGNALS); + ASSERT(0 == uv_run(loop, UV_RUN_DEFAULT)); + ASSERT(tc.ncalls == NSIGNALS); + ASSERT(sc.ncalls == NSIGNALS); sc.ncalls = 0; sc.stop_or_close = CLOSE; /* now close it when it's done */ uv_signal_start(&sc.handle, signal_cb, SIGCHLD); start_timer(loop, SIGCHLD, &tc); - ASSERT_OK(uv_run(loop, UV_RUN_DEFAULT)); - ASSERT_EQ(tc.ncalls, NSIGNALS); - ASSERT_EQ(sc.ncalls, NSIGNALS); + ASSERT(0 == uv_run(loop, UV_RUN_DEFAULT)); + ASSERT(tc.ncalls == NSIGNALS); + ASSERT(sc.ncalls == NSIGNALS); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -198,15 +198,15 @@ TEST_IMPL(we_get_signals) { start_watcher(loop, SIGUSR2, sc + 3, 0); start_timer(loop, SIGUSR1, tc + 0); start_timer(loop, SIGUSR2, tc + 1); - ASSERT_OK(uv_run(loop, UV_RUN_DEFAULT)); + ASSERT(0 == uv_run(loop, UV_RUN_DEFAULT)); for (i = 0; i < ARRAY_SIZE(sc); i++) - ASSERT_EQ(sc[i].ncalls, NSIGNALS); + ASSERT(sc[i].ncalls == NSIGNALS); for (i = 0; i < ARRAY_SIZE(tc); i++) - ASSERT_EQ(tc[i].ncalls, NSIGNALS); + ASSERT(tc[i].ncalls == NSIGNALS); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -219,23 +219,23 @@ TEST_IMPL(we_get_signal_one_shot) { start_timer(loop, SIGCHLD, &tc); start_watcher(loop, SIGCHLD, &sc, 1); sc.stop_or_close = NOOP; - ASSERT_OK(uv_run(loop, UV_RUN_DEFAULT)); - ASSERT_EQ(tc.ncalls, NSIGNALS); - ASSERT_EQ(1, sc.ncalls); + ASSERT(0 == uv_run(loop, UV_RUN_DEFAULT)); + ASSERT(tc.ncalls == NSIGNALS); + ASSERT(sc.ncalls == 1); start_timer(loop, SIGCHLD, &tc); - ASSERT_OK(uv_run(loop, UV_RUN_DEFAULT)); - ASSERT_EQ(1, sc.ncalls); + ASSERT(0 == uv_run(loop, UV_RUN_DEFAULT)); + ASSERT(sc.ncalls == 1); sc.ncalls = 0; sc.stop_or_close = CLOSE; /* now close it when it's done */ uv_signal_start_oneshot(&sc.handle, signal_cb_one_shot, SIGCHLD); start_timer(loop, SIGCHLD, &tc); - ASSERT_OK(uv_run(loop, UV_RUN_DEFAULT)); - ASSERT_EQ(tc.ncalls, NSIGNALS); - ASSERT_EQ(1, sc.ncalls); + ASSERT(0 == uv_run(loop, UV_RUN_DEFAULT)); + ASSERT(tc.ncalls == NSIGNALS); + ASSERT(sc.ncalls == 1); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -252,10 +252,10 @@ TEST_IMPL(we_get_signals_mixed) { start_watcher(loop, SIGCHLD, sc + 1, 1); sc[0].stop_or_close = CLOSE; sc[1].stop_or_close = CLOSE; - ASSERT_OK(uv_run(loop, UV_RUN_DEFAULT)); - ASSERT_EQ(tc.ncalls, NSIGNALS); - ASSERT_EQ(1, sc[0].ncalls); - ASSERT_EQ(1, sc[1].ncalls); + ASSERT(0 == uv_run(loop, UV_RUN_DEFAULT)); + ASSERT(tc.ncalls == NSIGNALS); + ASSERT(sc[0].ncalls == 1); + ASSERT(sc[1].ncalls == 1); /* 2 one-shot, 1 normal then remove normal */ start_timer(loop, SIGCHLD, &tc); @@ -265,11 +265,11 @@ TEST_IMPL(we_get_signals_mixed) { sc[1].stop_or_close = CLOSE; start_watcher(loop, SIGCHLD, sc + 2, 0); uv_close((uv_handle_t*)&(sc[2]).handle, NULL); - ASSERT_OK(uv_run(loop, UV_RUN_DEFAULT)); - ASSERT_EQ(tc.ncalls, NSIGNALS); - ASSERT_EQ(1, sc[0].ncalls); - ASSERT_EQ(1, sc[1].ncalls); - ASSERT_OK(sc[2].ncalls); + ASSERT(0 == uv_run(loop, UV_RUN_DEFAULT)); + ASSERT(tc.ncalls == NSIGNALS); + ASSERT(sc[0].ncalls == 1); + ASSERT(sc[1].ncalls == 1); + ASSERT(sc[2].ncalls == 0); /* 2 normal, 1 one-shot then remove one-shot */ start_timer(loop, SIGCHLD, &tc); @@ -279,11 +279,11 @@ TEST_IMPL(we_get_signals_mixed) { sc[1].stop_or_close = CLOSE; start_watcher(loop, SIGCHLD, sc + 2, 1); uv_close((uv_handle_t*)&(sc[2]).handle, NULL); - ASSERT_OK(uv_run(loop, UV_RUN_DEFAULT)); - ASSERT_EQ(tc.ncalls, NSIGNALS); - ASSERT_EQ(sc[0].ncalls, NSIGNALS); - ASSERT_EQ(sc[1].ncalls, NSIGNALS); - ASSERT_OK(sc[2].ncalls); + ASSERT(0 == uv_run(loop, UV_RUN_DEFAULT)); + ASSERT(tc.ncalls == NSIGNALS); + ASSERT(sc[0].ncalls == NSIGNALS); + ASSERT(sc[1].ncalls == NSIGNALS); + ASSERT(sc[2].ncalls == 0); /* 2 normal, 2 one-shot then remove 2 normal */ start_timer(loop, SIGCHLD, &tc); @@ -295,12 +295,12 @@ TEST_IMPL(we_get_signals_mixed) { sc[3].stop_or_close = CLOSE; uv_close((uv_handle_t*)&(sc[0]).handle, NULL); uv_close((uv_handle_t*)&(sc[1]).handle, NULL); - ASSERT_OK(uv_run(loop, UV_RUN_DEFAULT)); - ASSERT_EQ(tc.ncalls, NSIGNALS); - ASSERT_OK(sc[0].ncalls); - ASSERT_OK(sc[1].ncalls); - ASSERT_EQ(1, sc[2].ncalls); - ASSERT_EQ(1, sc[2].ncalls); + ASSERT(0 == uv_run(loop, UV_RUN_DEFAULT)); + ASSERT(tc.ncalls == NSIGNALS); + ASSERT(sc[0].ncalls == 0); + ASSERT(sc[1].ncalls == 0); + ASSERT(sc[2].ncalls == 1); + ASSERT(sc[2].ncalls == 1); /* 1 normal, 1 one-shot, 2 normal then remove 1st normal, 2nd normal */ start_timer(loop, SIGCHLD, &tc); @@ -311,14 +311,14 @@ TEST_IMPL(we_get_signals_mixed) { sc[3].stop_or_close = CLOSE; uv_close((uv_handle_t*)&(sc[0]).handle, NULL); uv_close((uv_handle_t*)&(sc[2]).handle, NULL); - ASSERT_OK(uv_run(loop, UV_RUN_DEFAULT)); - ASSERT_EQ(tc.ncalls, NSIGNALS); - ASSERT_OK(sc[0].ncalls); - ASSERT_EQ(1, sc[1].ncalls); - ASSERT_OK(sc[2].ncalls); - ASSERT_EQ(sc[3].ncalls, NSIGNALS); - - MAKE_VALGRIND_HAPPY(loop); + ASSERT(0 == uv_run(loop, UV_RUN_DEFAULT)); + ASSERT(tc.ncalls == NSIGNALS); + ASSERT(sc[0].ncalls == 0); + ASSERT(sc[1].ncalls == 1); + ASSERT(sc[2].ncalls == 0); + ASSERT(sc[3].ncalls == NSIGNALS); + + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-socket-buffer-size.c b/test/test-socket-buffer-size.c index 64904e9..72f8c25 100644 --- a/test/test-socket-buffer-size.c +++ b/test/test-socket-buffer-size.c @@ -40,14 +40,14 @@ static void check_buffer_size(uv_handle_t* handle) { int value; value = 0; - ASSERT_OK(uv_recv_buffer_size(handle, &value)); - ASSERT_GT(value, 0); + ASSERT(0 == uv_recv_buffer_size(handle, &value)); + ASSERT(value > 0); value = 10000; - ASSERT_OK(uv_recv_buffer_size(handle, &value)); + ASSERT(0 == uv_recv_buffer_size(handle, &value)); value = 0; - ASSERT_OK(uv_recv_buffer_size(handle, &value)); + ASSERT(0 == uv_recv_buffer_size(handle, &value)); /* linux sets double the value */ ASSERT(value == 10000 || value == 20000); } @@ -56,22 +56,22 @@ static void check_buffer_size(uv_handle_t* handle) { TEST_IMPL(socket_buffer_size) { struct sockaddr_in addr; - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); + ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); - ASSERT_OK(uv_tcp_init(uv_default_loop(), &tcp)); - ASSERT_OK(uv_tcp_bind(&tcp, (struct sockaddr*) &addr, 0)); + ASSERT(0 == uv_tcp_init(uv_default_loop(), &tcp)); + ASSERT(0 == uv_tcp_bind(&tcp, (struct sockaddr*) &addr, 0)); check_buffer_size((uv_handle_t*) &tcp); uv_close((uv_handle_t*) &tcp, close_cb); - ASSERT_OK(uv_udp_init(uv_default_loop(), &udp)); - ASSERT_OK(uv_udp_bind(&udp, (struct sockaddr*) &addr, 0)); + ASSERT(0 == uv_udp_init(uv_default_loop(), &udp)); + ASSERT(0 == uv_udp_bind(&udp, (struct sockaddr*) &addr, 0)); check_buffer_size((uv_handle_t*) &udp); uv_close((uv_handle_t*) &udp, close_cb); - ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT)); + ASSERT(0 == uv_run(uv_default_loop(), UV_RUN_DEFAULT)); - ASSERT_EQ(2, close_cb_called); + ASSERT(close_cb_called == 2); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-spawn.c b/test/test-spawn.c index 6a84874..8674960 100644 --- a/test/test-spawn.c +++ b/test/test-spawn.c @@ -32,9 +32,6 @@ # include # include typedef BOOL (WINAPI *sCompareObjectHandles)(_In_ HANDLE, _In_ HANDLE); -# define unlink _unlink -# define putenv _putenv -# define close _close #else # include # include @@ -68,8 +65,8 @@ static void exit_cb(uv_process_t* process, int term_signal) { printf("exit_cb\n"); exit_cb_called++; - ASSERT_EQ(1, exit_status); - ASSERT_OK(term_signal); + ASSERT(exit_status == 1); + ASSERT(term_signal == 0); uv_close((uv_handle_t*) process, close_cb); } @@ -77,7 +74,7 @@ static void exit_cb(uv_process_t* process, static void fail_cb(uv_process_t* process, int64_t exit_status, int term_signal) { - ASSERT(0 && "fail_cb called"); + return; } @@ -89,9 +86,9 @@ static void kill_cb(uv_process_t* process, printf("exit_cb\n"); exit_cb_called++; #ifdef _WIN32 - ASSERT_EQ(1, exit_status); + ASSERT(exit_status == 1); #else - ASSERT_OK(exit_status); + ASSERT(exit_status == 0); #endif #if defined(__APPLE__) || defined(__MVS__) /* @@ -111,7 +108,7 @@ static void kill_cb(uv_process_t* process, * This process should be dead. */ err = uv_kill(process->pid, 0); - ASSERT_EQ(err, UV_ESRCH); + ASSERT(err == UV_ESRCH); } static void detach_failure_cb(uv_process_t* process, @@ -133,7 +130,7 @@ static void on_read(uv_stream_t* tcp, ssize_t nread, const uv_buf_t* buf) { if (nread > 0) { output_used += nread; } else if (nread < 0) { - ASSERT_EQ(nread, UV_EOF); + ASSERT(nread == UV_EOF); uv_close((uv_handle_t*) tcp, close_cb); } } @@ -146,20 +143,20 @@ static void on_read_once(uv_stream_t* tcp, ssize_t nread, const uv_buf_t* buf) { static void write_cb(uv_write_t* req, int status) { - ASSERT_OK(status); + ASSERT(status == 0); uv_close((uv_handle_t*) req->handle, close_cb); } static void write_null_cb(uv_write_t* req, int status) { - ASSERT_OK(status); + ASSERT(status == 0); } static void init_process_options(char* test, uv_exit_cb exit_cb) { /* Note spawn_helper1 defined in test/run-tests.c */ int r = uv_exepath(exepath, &exepath_size); - ASSERT_OK(r); + ASSERT(r == 0); exepath[exepath_size] = '\0'; args[0] = exepath; args[1] = test; @@ -192,11 +189,11 @@ TEST_IMPL(spawn_fails) { r = uv_spawn(uv_default_loop(), &process, &options); ASSERT(r == UV_ENOENT || r == UV_EACCES); - ASSERT_OK(uv_is_active((uv_handle_t*) &process)); + ASSERT(0 == uv_is_active((uv_handle_t*) &process)); uv_close((uv_handle_t*) &process, NULL); - ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT)); + ASSERT(0 == uv_run(uv_default_loop(), UV_RUN_DEFAULT)); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -212,21 +209,21 @@ TEST_IMPL(spawn_fails_check_for_waitpid_cleanup) { r = uv_spawn(uv_default_loop(), &process, &options); ASSERT(r == UV_ENOENT || r == UV_EACCES); - ASSERT_OK(uv_is_active((uv_handle_t*) &process)); - ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT)); + ASSERT(0 == uv_is_active((uv_handle_t*) &process)); + ASSERT(0 == uv_run(uv_default_loop(), UV_RUN_DEFAULT)); /* verify the child is successfully cleaned up within libuv */ do err = waitpid(process.pid, &status, 0); while (err == -1 && errno == EINTR); - ASSERT_EQ(err, -1); - ASSERT_EQ(errno, ECHILD); + ASSERT(err == -1); + ASSERT(errno == ECHILD); uv_close((uv_handle_t*) &process, NULL); - ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT)); + ASSERT(0 == uv_run(uv_default_loop(), UV_RUN_DEFAULT)); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } #endif @@ -250,13 +247,13 @@ TEST_IMPL(spawn_empty_env) { options.env = env; env[0] = NULL; - ASSERT_OK(uv_spawn(uv_default_loop(), &process, &options)); - ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT)); + ASSERT(0 == uv_spawn(uv_default_loop(), &process, &options)); + ASSERT(0 == uv_run(uv_default_loop(), UV_RUN_DEFAULT)); - ASSERT_EQ(1, exit_cb_called); - ASSERT_EQ(1, close_cb_called); + ASSERT(exit_cb_called == 1); + ASSERT(close_cb_called == 1); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -267,15 +264,15 @@ TEST_IMPL(spawn_exit_code) { init_process_options("spawn_helper1", exit_cb); r = uv_spawn(uv_default_loop(), &process, &options); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_EQ(1, exit_cb_called); - ASSERT_EQ(1, close_cb_called); + ASSERT(exit_cb_called == 1); + ASSERT(close_cb_called == 1); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -295,20 +292,20 @@ TEST_IMPL(spawn_stdout) { options.stdio_count = 2; r = uv_spawn(uv_default_loop(), &process, &options); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_read_start((uv_stream_t*) &out, on_alloc, on_read); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_EQ(1, exit_cb_called); - ASSERT_EQ(2, close_cb_called); /* Once for process once for the pipe. */ + ASSERT(exit_cb_called == 1); + ASSERT(close_cb_called == 2); /* Once for process once for the pipe. */ printf("output is: %s", output); - ASSERT_OK(strcmp("hello world\n", output)); + ASSERT(strcmp("hello world\n", output) == 0); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -325,9 +322,9 @@ TEST_IMPL(spawn_stdout_to_file) { init_process_options("spawn_helper2", exit_cb); - r = uv_fs_open(NULL, &fs_req, "stdout_file", UV_FS_O_CREAT | UV_FS_O_RDWR, + r = uv_fs_open(NULL, &fs_req, "stdout_file", O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, NULL); - ASSERT_NE(r, -1); + ASSERT(r != -1); uv_fs_req_cleanup(&fs_req); file = r; @@ -339,30 +336,30 @@ TEST_IMPL(spawn_stdout_to_file) { options.stdio_count = 2; r = uv_spawn(uv_default_loop(), &process, &options); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_EQ(1, exit_cb_called); - ASSERT_EQ(1, close_cb_called); + ASSERT(exit_cb_called == 1); + ASSERT(close_cb_called == 1); buf = uv_buf_init(output, sizeof(output)); r = uv_fs_read(NULL, &fs_req, file, &buf, 1, 0, NULL); - ASSERT_EQ(12, r); + ASSERT(r == 12); uv_fs_req_cleanup(&fs_req); r = uv_fs_close(NULL, &fs_req, file, NULL); - ASSERT_OK(r); + ASSERT(r == 0); uv_fs_req_cleanup(&fs_req); printf("output is: %s", output); - ASSERT_OK(strcmp("hello world\n", output)); + ASSERT(strcmp("hello world\n", output) == 0); /* Cleanup. */ unlink("stdout_file"); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -379,9 +376,9 @@ TEST_IMPL(spawn_stdout_and_stderr_to_file) { init_process_options("spawn_helper6", exit_cb); - r = uv_fs_open(NULL, &fs_req, "stdout_file", UV_FS_O_CREAT | UV_FS_O_RDWR, + r = uv_fs_open(NULL, &fs_req, "stdout_file", O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, NULL); - ASSERT_NE(r, -1); + ASSERT(r != -1); uv_fs_req_cleanup(&fs_req); file = r; @@ -395,30 +392,30 @@ TEST_IMPL(spawn_stdout_and_stderr_to_file) { options.stdio_count = 3; r = uv_spawn(uv_default_loop(), &process, &options); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_EQ(1, exit_cb_called); - ASSERT_EQ(1, close_cb_called); + ASSERT(exit_cb_called == 1); + ASSERT(close_cb_called == 1); buf = uv_buf_init(output, sizeof(output)); r = uv_fs_read(NULL, &fs_req, file, &buf, 1, 0, NULL); - ASSERT_EQ(27, r); + ASSERT(r == 27); uv_fs_req_cleanup(&fs_req); r = uv_fs_close(NULL, &fs_req, file, NULL); - ASSERT_OK(r); + ASSERT(r == 0); uv_fs_req_cleanup(&fs_req); printf("output is: %s", output); - ASSERT_OK(strcmp("hello world\nhello errworld\n", output)); + ASSERT(strcmp("hello world\nhello errworld\n", output) == 0); /* Cleanup. */ unlink("stdout_file"); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -443,10 +440,10 @@ TEST_IMPL(spawn_stdout_and_stderr_to_file2) { O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, NULL); - ASSERT_NE(r, -1); + ASSERT(r != -1); uv_fs_req_cleanup(&fs_req); file = dup2(r, STDERR_FILENO); - ASSERT_NE(file, -1); + ASSERT(file != -1); options.stdio = stdio; options.stdio[0].flags = UV_IGNORE; @@ -457,30 +454,30 @@ TEST_IMPL(spawn_stdout_and_stderr_to_file2) { options.stdio_count = 3; r = uv_spawn(uv_default_loop(), &process, &options); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_EQ(1, exit_cb_called); - ASSERT_EQ(1, close_cb_called); + ASSERT(exit_cb_called == 1); + ASSERT(close_cb_called == 1); buf = uv_buf_init(output, sizeof(output)); r = uv_fs_read(NULL, &fs_req, file, &buf, 1, 0, NULL); - ASSERT_EQ(27, r); + ASSERT(r == 27); uv_fs_req_cleanup(&fs_req); r = uv_fs_close(NULL, &fs_req, file, NULL); - ASSERT_OK(r); + ASSERT(r == 0); uv_fs_req_cleanup(&fs_req); printf("output is: %s", output); - ASSERT_OK(strcmp("hello world\nhello errworld\n", output)); + ASSERT(strcmp("hello world\nhello errworld\n", output) == 0); /* Cleanup. */ unlink("stdout_file"); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; #else RETURN_SKIP("Unix only test"); @@ -510,18 +507,18 @@ TEST_IMPL(spawn_stdout_and_stderr_to_file_swap) { O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, NULL); - ASSERT_NE(r, -1); + ASSERT(r != -1); uv_fs_req_cleanup(&fs_req); stdout_file = dup2(r, STDOUT_FILENO); - ASSERT_NE(stdout_file, -1); + ASSERT(stdout_file != -1); /* open 'stderr_file' and replace STDERR_FILENO with it */ r = uv_fs_open(NULL, &fs_req, "stderr_file", O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, NULL); - ASSERT_NE(r, -1); + ASSERT(r != -1); uv_fs_req_cleanup(&fs_req); stderr_file = dup2(r, STDERR_FILENO); - ASSERT_NE(stderr_file, -1); + ASSERT(stderr_file != -1); /* now we're going to swap them: the child process' stdout will be our * stderr_file and vice versa */ @@ -534,45 +531,45 @@ TEST_IMPL(spawn_stdout_and_stderr_to_file_swap) { options.stdio_count = 3; r = uv_spawn(uv_default_loop(), &process, &options); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_EQ(1, exit_cb_called); - ASSERT_EQ(1, close_cb_called); + ASSERT(exit_cb_called == 1); + ASSERT(close_cb_called == 1); buf = uv_buf_init(output, sizeof(output)); /* check the content of stdout_file */ r = uv_fs_read(NULL, &fs_req, stdout_file, &buf, 1, 0, NULL); - ASSERT_GE(r, 15); + ASSERT(r >= 15); uv_fs_req_cleanup(&fs_req); r = uv_fs_close(NULL, &fs_req, stdout_file, NULL); - ASSERT_OK(r); + ASSERT(r == 0); uv_fs_req_cleanup(&fs_req); printf("output is: %s", output); - ASSERT_OK(strncmp("hello errworld\n", output, 15)); + ASSERT(strncmp("hello errworld\n", output, 15) == 0); /* check the content of stderr_file */ r = uv_fs_read(NULL, &fs_req, stderr_file, &buf, 1, 0, NULL); - ASSERT_GE(r, 12); + ASSERT(r >= 12); uv_fs_req_cleanup(&fs_req); r = uv_fs_close(NULL, &fs_req, stderr_file, NULL); - ASSERT_OK(r); + ASSERT(r == 0); uv_fs_req_cleanup(&fs_req); printf("output is: %s", output); - ASSERT_OK(strncmp("hello world\n", output, 12)); + ASSERT(strncmp("hello world\n", output, 12) == 0); /* Cleanup. */ unlink("stdout_file"); unlink("stderr_file"); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; #else RETURN_SKIP("Unix only test"); @@ -601,24 +598,24 @@ TEST_IMPL(spawn_stdin) { options.stdio_count = 2; r = uv_spawn(uv_default_loop(), &process, &options); - ASSERT_OK(r); + ASSERT(r == 0); buf.base = buffer; buf.len = sizeof(buffer); r = uv_write(&write_req, (uv_stream_t*) &in, &buf, 1, write_cb); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_read_start((uv_stream_t*) &out, on_alloc, on_read); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_EQ(1, exit_cb_called); - ASSERT_EQ(3, close_cb_called); /* Once for process twice for the pipe. */ - ASSERT_OK(strcmp(buffer, output)); + ASSERT(exit_cb_called == 1); + ASSERT(close_cb_called == 3); /* Once for process twice for the pipe. */ + ASSERT(strcmp(buffer, output) == 0); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -640,20 +637,20 @@ TEST_IMPL(spawn_stdio_greater_than_3) { options.stdio_count = 4; r = uv_spawn(uv_default_loop(), &process, &options); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_read_start((uv_stream_t*) &pipe, on_alloc, on_read); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_EQ(1, exit_cb_called); - ASSERT_EQ(2, close_cb_called); /* Once for process once for the pipe. */ + ASSERT(exit_cb_called == 1); + ASSERT(close_cb_called == 2); /* Once for process once for the pipe. */ printf("output from stdio[3] is: %s", output); - ASSERT_OK(strcmp("fourth stdio!\n", output)); + ASSERT(strcmp("fourth stdio!\n", output) == 0); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -664,7 +661,7 @@ int spawn_tcp_server_helper(void) { int r; r = uv_tcp_init(uv_default_loop(), &tcp); - ASSERT_OK(r); + ASSERT(r == 0); #ifdef _WIN32 handle = _get_osfhandle(3); @@ -672,13 +669,13 @@ int spawn_tcp_server_helper(void) { handle = 3; #endif r = uv_tcp_open(&tcp, handle); - ASSERT_OK(r); + ASSERT(r == 0); /* Make sure that we can listen on a socket that was * passed down from the parent process */ r = uv_listen((uv_stream_t*) &tcp, SOMAXCONN, NULL); - ASSERT_OK(r); + ASSERT(r == 0); return 1; } @@ -695,21 +692,21 @@ TEST_IMPL(spawn_tcp_server) { init_process_options("spawn_tcp_server_helper", exit_cb); - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); + ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); fd = -1; r = uv_tcp_init_ex(uv_default_loop(), &tcp_server, AF_INET); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_tcp_bind(&tcp_server, (const struct sockaddr*) &addr, 0); - ASSERT_OK(r); + ASSERT(r == 0); #ifdef _WIN32 r = uv_fileno((uv_handle_t*) &tcp_server, &handle); fd = _open_osfhandle((intptr_t) handle, 0); #else r = uv_fileno((uv_handle_t*) &tcp_server, &fd); #endif - ASSERT_OK(r); - ASSERT_GT(fd, 0); + ASSERT(r == 0); + ASSERT(fd > 0); options.stdio = stdio; options.stdio[0].flags = UV_INHERIT_FD; @@ -723,15 +720,15 @@ TEST_IMPL(spawn_tcp_server) { options.stdio_count = 4; r = uv_spawn(uv_default_loop(), &process, &options); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_EQ(1, exit_cb_called); - ASSERT_EQ(1, close_cb_called); + ASSERT(exit_cb_called == 1); + ASSERT(close_cb_called == 1); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -745,15 +742,15 @@ TEST_IMPL(spawn_ignored_stdio) { options.stdio_count = 0; r = uv_spawn(uv_default_loop(), &process, &options); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_EQ(1, exit_cb_called); - ASSERT_EQ(1, close_cb_called); + ASSERT(exit_cb_called == 1); + ASSERT(close_cb_called == 1); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -764,21 +761,21 @@ TEST_IMPL(spawn_and_kill) { init_process_options("spawn_helper4", kill_cb); r = uv_spawn(uv_default_loop(), &process, &options); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_timer_init(uv_default_loop(), &timer); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_timer_start(&timer, timer_cb, 500, 0); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_EQ(1, exit_cb_called); - ASSERT_EQ(2, close_cb_called); /* Once for process and once for timer. */ + ASSERT(exit_cb_called == 1); + ASSERT(close_cb_called == 2); /* Once for process and once for timer. */ - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -798,27 +795,27 @@ TEST_IMPL(spawn_preserve_env) { options.stdio_count = 2; r = putenv("ENV_TEST=testval"); - ASSERT_OK(r); + ASSERT(r == 0); /* Explicitly set options.env to NULL to test for env clobbering. */ options.env = NULL; r = uv_spawn(uv_default_loop(), &process, &options); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_read_start((uv_stream_t*) &out, on_alloc, on_read); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_EQ(1, exit_cb_called); - ASSERT_EQ(2, close_cb_called); + ASSERT(exit_cb_called == 1); + ASSERT(close_cb_called == 2); printf("output is: %s", output); - ASSERT_OK(strcmp("testval", output)); + ASSERT(strcmp("testval", output) == 0); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -831,24 +828,24 @@ TEST_IMPL(spawn_detached) { options.flags |= UV_PROCESS_DETACHED; r = uv_spawn(uv_default_loop(), &process, &options); - ASSERT_OK(r); + ASSERT(r == 0); uv_unref((uv_handle_t*) &process); r = uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_OK(exit_cb_called); + ASSERT(exit_cb_called == 0); - ASSERT_EQ(process.pid, uv_process_get_pid(&process)); + ASSERT(process.pid == uv_process_get_pid(&process)); r = uv_kill(process.pid, 0); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_kill(process.pid, SIGTERM); - ASSERT_OK(r); + ASSERT(r == 0); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -864,13 +861,13 @@ TEST_IMPL(spawn_and_kill_with_std) { init_process_options("spawn_helper4", kill_cb); r = uv_pipe_init(uv_default_loop(), &in, 0); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_pipe_init(uv_default_loop(), &out, 0); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_pipe_init(uv_default_loop(), &err, 0); - ASSERT_OK(r); + ASSERT(r == 0); options.stdio = stdio; options.stdio[0].flags = UV_CREATE_PIPE | UV_READABLE_PIPE; @@ -882,31 +879,31 @@ TEST_IMPL(spawn_and_kill_with_std) { options.stdio_count = 3; r = uv_spawn(uv_default_loop(), &process, &options); - ASSERT_OK(r); + ASSERT(r == 0); buf = uv_buf_init(message, sizeof message); r = uv_write(&write, (uv_stream_t*) &in, &buf, 1, write_cb); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_read_start((uv_stream_t*) &out, on_alloc, on_read); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_read_start((uv_stream_t*) &err, on_alloc, on_read); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_timer_init(uv_default_loop(), &timer); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_timer_start(&timer, timer_cb, 500, 0); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_EQ(1, exit_cb_called); - ASSERT_EQ(5, close_cb_called); /* process x 1, timer x 1, stdio x 3. */ + ASSERT(exit_cb_called == 1); + ASSERT(close_cb_called == 5); /* process x 1, timer x 1, stdio x 3. */ - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -931,29 +928,29 @@ TEST_IMPL(spawn_and_ping) { options.stdio_count = 2; r = uv_spawn(uv_default_loop(), &process, &options); - ASSERT_OK(r); + ASSERT(r == 0); /* Sending signum == 0 should check if the * child process is still alive, not kill it. */ r = uv_process_kill(&process, 0); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_write(&write_req, (uv_stream_t*) &in, &buf, 1, write_cb); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_read_start((uv_stream_t*) &out, on_alloc, on_read); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_OK(exit_cb_called); + ASSERT(exit_cb_called == 0); r = uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_EQ(1, exit_cb_called); - ASSERT_OK(strcmp(output, "TEST")); + ASSERT(exit_cb_called == 1); + ASSERT(strcmp(output, "TEST") == 0); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -978,29 +975,29 @@ TEST_IMPL(spawn_same_stdout_stderr) { options.stdio_count = 2; r = uv_spawn(uv_default_loop(), &process, &options); - ASSERT_OK(r); + ASSERT(r == 0); /* Sending signum == 0 should check if the * child process is still alive, not kill it. */ r = uv_process_kill(&process, 0); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_write(&write_req, (uv_stream_t*) &in, &buf, 1, write_cb); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_read_start((uv_stream_t*) &out, on_alloc, on_read); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_OK(exit_cb_called); + ASSERT(exit_cb_called == 0); r = uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_EQ(1, exit_cb_called); - ASSERT_OK(strcmp(output, "TEST")); + ASSERT(exit_cb_called == 1); + ASSERT(strcmp(output, "TEST") == 0); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -1022,17 +1019,17 @@ TEST_IMPL(spawn_closed_process_io) { close(0); /* Close process stdin. */ - ASSERT_OK(uv_spawn(uv_default_loop(), &process, &options)); + ASSERT(0 == uv_spawn(uv_default_loop(), &process, &options)); buf = uv_buf_init(buffer, sizeof(buffer)); - ASSERT_OK(uv_write(&write_req, (uv_stream_t*) &in, &buf, 1, write_cb)); + ASSERT(0 == uv_write(&write_req, (uv_stream_t*) &in, &buf, 1, write_cb)); - ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT)); + ASSERT(0 == uv_run(uv_default_loop(), UV_RUN_DEFAULT)); - ASSERT_EQ(1, exit_cb_called); - ASSERT_EQ(2, close_cb_called); /* process, child stdin */ + ASSERT(exit_cb_called == 1); + ASSERT(close_cb_called == 2); /* process, child stdin */ - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -1052,41 +1049,41 @@ TEST_IMPL(kill) { sigset_t set; sigemptyset(&set); sigaddset(&set, SIGTERM); - ASSERT_OK(pthread_sigmask(SIG_BLOCK, &set, NULL)); + ASSERT(0 == pthread_sigmask(SIG_BLOCK, &set, NULL)); } - ASSERT_NE(SIG_ERR, signal(SIGTERM, SIG_IGN)); + ASSERT(SIG_ERR != signal(SIGTERM, SIG_IGN)); #endif r = uv_spawn(uv_default_loop(), &process, &options); - ASSERT_OK(r); + ASSERT(r == 0); #ifndef _WIN32 { sigset_t set; sigemptyset(&set); sigaddset(&set, SIGTERM); - ASSERT_OK(pthread_sigmask(SIG_UNBLOCK, &set, NULL)); + ASSERT(0 == pthread_sigmask(SIG_UNBLOCK, &set, NULL)); } - ASSERT_NE(SIG_ERR, signal(SIGTERM, SIG_DFL)); + ASSERT(SIG_ERR != signal(SIGTERM, SIG_DFL)); #endif /* Sending signum == 0 should check if the * child process is still alive, not kill it. */ r = uv_kill(process.pid, 0); - ASSERT_OK(r); + ASSERT(r == 0); /* Kill the process. */ r = uv_kill(process.pid, SIGTERM); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_EQ(1, exit_cb_called); - ASSERT_EQ(1, close_cb_called); + ASSERT(exit_cb_called == 1); + ASSERT(close_cb_called == 1); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -1111,7 +1108,7 @@ TEST_IMPL(spawn_detect_pipe_name_collisions_on_windows) { /* Create a pipe that'll cause a collision. */ snprintf(name, sizeof(name), - "\\\\.\\pipe\\uv\\%p-%lu", + "\\\\.\\pipe\\uv\\%p-%d", &out, GetCurrentProcessId()); pipe_handle = CreateNamedPipeA(name, @@ -1122,23 +1119,23 @@ TEST_IMPL(spawn_detect_pipe_name_collisions_on_windows) { 65536, 0, NULL); - ASSERT_PTR_NE(pipe_handle, INVALID_HANDLE_VALUE); + ASSERT(pipe_handle != INVALID_HANDLE_VALUE); r = uv_spawn(uv_default_loop(), &process, &options); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_read_start((uv_stream_t*) &out, on_alloc, on_read); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_EQ(1, exit_cb_called); - ASSERT_EQ(2, close_cb_called); /* Once for process once for the pipe. */ + ASSERT(exit_cb_called == 1); + ASSERT(close_cb_called == 2); /* Once for process once for the pipe. */ printf("output is: %s", output); - ASSERT_OK(strcmp("hello world\n", output)); + ASSERT(strcmp("hello world\n", output) == 0); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -1200,7 +1197,7 @@ TEST_IMPL(argument_escaping) { cracked = CommandLineToArgvW(command_line, &num_args); for (i = 0; i < num_args; ++i) { wprintf(L"%d: %s\t%s\n", i, test_str[i], cracked[i]); - ASSERT_OK(wcscmp(test_str[i], cracked[i])); + ASSERT(wcscmp(test_str[i], cracked[i]) == 0); } LocalFree(cracked); @@ -1210,19 +1207,19 @@ TEST_IMPL(argument_escaping) { free(test_output); result = make_program_args(verbatim, 1, &verbatim_output); - ASSERT_OK(result); + ASSERT(result == 0); result = make_program_args(verbatim, 0, &non_verbatim_output); - ASSERT_OK(result); + ASSERT(result == 0); wprintf(L" verbatim_output: %s\n", verbatim_output); wprintf(L"non_verbatim_output: %s\n", non_verbatim_output); - ASSERT_OK(wcscmp(verbatim_output, - L"cmd.exe /c c:\\path\\to\\node.exe --eval " - L"\"require('c:\\\\path\\\\to\\\\test.js')\"")); - ASSERT_OK(wcscmp(non_verbatim_output, - L"cmd.exe /c \"c:\\path\\to\\node.exe --eval " - L"\\\"require('c:\\\\path\\\\to\\\\test.js')\\\"\"")); + ASSERT(wcscmp(verbatim_output, + L"cmd.exe /c c:\\path\\to\\node.exe --eval " + L"\"require('c:\\\\path\\\\to\\\\test.js')\"") == 0); + ASSERT(wcscmp(non_verbatim_output, + L"cmd.exe /c \"c:\\path\\to\\node.exe --eval " + L"\\\"require('c:\\\\path\\\\to\\\\test.js')\\\"\"") == 0); free(verbatim_output); free(non_verbatim_output); @@ -1306,7 +1303,7 @@ TEST_IMPL(environment_creation) { } result = make_program_env(environment, &env); - ASSERT_OK(result); + ASSERT(result == 0); for (str = env, prev = NULL; *str; prev = str, str += wcslen(str) + 1) { int found = 0; @@ -1330,7 +1327,7 @@ TEST_IMPL(environment_creation) { } if (prev) { /* verify sort order */ #if !defined(__MINGW32__) || defined(__MINGW64_VERSION_MAJOR) - ASSERT_EQ(1, CompareStringOrdinal(prev, -1, str, -1, TRUE)); + ASSERT(CompareStringOrdinal(prev, -1, str, -1, TRUE) == 1); #endif } ASSERT(found); /* verify that we expected this variable */ @@ -1362,143 +1359,11 @@ TEST_IMPL(spawn_with_an_odd_path) { options.file = options.args[0] = "program-that-had-better-not-exist"; r = uv_spawn(uv_default_loop(), &process, &options); ASSERT(r == UV_ENOENT || r == UV_EACCES); - ASSERT_OK(uv_is_active((uv_handle_t*) &process)); - uv_close((uv_handle_t*) &process, NULL); - ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT)); - - MAKE_VALGRIND_HAPPY(uv_default_loop()); - return 0; -} - - -TEST_IMPL(spawn_no_path) { - char* env[1]; - WCHAR* old_path = NULL; - DWORD old_path_len; - - if ((old_path_len = GetEnvironmentVariableW(L"PATH", NULL, 0)) > 0) { - old_path = malloc(old_path_len * sizeof(WCHAR)); - GetEnvironmentVariableW(L"PATH", old_path, old_path_len); - SetEnvironmentVariableW(L"PATH", NULL); - } - - init_process_options("spawn_helper1", exit_cb); - options.env = env; - env[0] = NULL; - - ASSERT_OK(uv_spawn(uv_default_loop(), &process, &options)); - ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT)); - - ASSERT_EQ(1, exit_cb_called); - ASSERT_EQ(1, close_cb_called); - - SetEnvironmentVariableW(L"PATH", old_path); - - MAKE_VALGRIND_HAPPY(uv_default_loop()); - return 0; -} - - -TEST_IMPL(spawn_no_ext) { - char new_exepath[1024]; - - init_process_options("spawn_helper1", exit_cb); - options.flags |= UV_PROCESS_WINDOWS_FILE_PATH_EXACT_NAME; - snprintf(new_exepath, sizeof(new_exepath), "%.*s_no_ext", - (int) (exepath_size - sizeof(".exe") + 1), - exepath); - options.file = options.args[0] = new_exepath; - - ASSERT_OK(uv_spawn(uv_default_loop(), &process, &options)); - ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT)); - - ASSERT_EQ(1, exit_cb_called); - ASSERT_EQ(1, close_cb_called); - - MAKE_VALGRIND_HAPPY(uv_default_loop()); - return 0; -} - - -TEST_IMPL(spawn_path_no_ext) { - int r; - int len; - int file_len; - char file[64]; - char path[1024]; - char* env[2]; - - /* Set up the process, but make sure that the file to run is relative and - * requires a lookup into PATH. */ - init_process_options("spawn_helper1", exit_cb); - options.flags |= UV_PROCESS_WINDOWS_FILE_PATH_EXACT_NAME; - - /* Set up the PATH env variable */ - for (len = strlen(exepath), file_len = 0; - exepath[len - 1] != '/' && exepath[len - 1] != '\\'; - len--, file_len++); - snprintf(file, sizeof(file), "%.*s_no_ext", - (int) (file_len - sizeof(".exe") + 1), - exepath + len); - exepath[len] = 0; - snprintf(path, sizeof(path), "PATH=%s", exepath); - - env[0] = path; - env[1] = NULL; - - options.file = options.args[0] = file; - options.env = env; - - r = uv_spawn(uv_default_loop(), &process, &options); - ASSERT(r == UV_ENOENT || r == UV_EACCES); - ASSERT_OK(uv_is_active((uv_handle_t*) &process)); + ASSERT(0 == uv_is_active((uv_handle_t*) &process)); uv_close((uv_handle_t*) &process, NULL); - ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT)); - - MAKE_VALGRIND_HAPPY(uv_default_loop()); - return 0; -} -#endif - -#ifndef _WIN32 -TEST_IMPL(spawn_setuid_setgid) { - int r; - struct passwd* pw; - char uidstr[10]; - char gidstr[10]; - - /* if not root, then this will fail. */ - uv_uid_t uid = getuid(); - if (uid != 0) { - RETURN_SKIP("It should be run as root user"); - } - - init_process_options("spawn_helper_setuid_setgid", exit_cb); - - /* become the "nobody" user. */ - pw = getpwnam("nobody"); - ASSERT_NOT_NULL(pw); - options.uid = pw->pw_uid; - options.gid = pw->pw_gid; - snprintf(uidstr, sizeof(uidstr), "%d", pw->pw_uid); - snprintf(gidstr, sizeof(gidstr), "%d", pw->pw_gid); - options.args[2] = uidstr; - options.args[3] = gidstr; - options.flags = UV_PROCESS_SETUID | UV_PROCESS_SETGID; - - r = uv_spawn(uv_default_loop(), &process, &options); - if (r == UV_EACCES) - RETURN_SKIP("user 'nobody' cannot access the test runner"); - - ASSERT_OK(r); - - r = uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_OK(r); - - ASSERT_EQ(1, exit_cb_called); - ASSERT_EQ(1, close_cb_called); + ASSERT(0 == uv_run(uv_default_loop(), UV_RUN_DEFAULT)); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } #endif @@ -1507,24 +1372,10 @@ TEST_IMPL(spawn_setuid_setgid) { #ifndef _WIN32 TEST_IMPL(spawn_setuid_fails) { int r; - - /* if root, become nobody. */ - /* On IBMi PASE, there is no nobody user. */ -#ifndef __PASE__ - uv_uid_t uid = getuid(); - if (uid == 0) { - struct passwd* pw; - pw = getpwnam("nobody"); - ASSERT_NOT_NULL(pw); - ASSERT_OK(setgid(pw->pw_gid)); - ASSERT_OK(setuid(pw->pw_uid)); - } -#endif /* !__PASE__ */ - init_process_options("spawn_helper1", fail_cb); options.flags |= UV_PROCESS_SETUID; - /* On IBMi PASE, there is no root user. User may grant + /* On IBMi PASE, there is no root user. User may grant * root-like privileges, including setting uid to 0. */ #if defined(__PASE__) @@ -1541,41 +1392,25 @@ TEST_IMPL(spawn_setuid_fails) { r = uv_spawn(uv_default_loop(), &process, &options); #if defined(__CYGWIN__) - ASSERT_EQ(r, UV_EINVAL); -#else - ASSERT_EQ(r, UV_EPERM); + ASSERT(r == UV_EINVAL); #endif r = uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_OK(close_cb_called); + ASSERT(close_cb_called == 0); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } TEST_IMPL(spawn_setgid_fails) { int r; - - /* if root, become nobody. */ - /* On IBMi PASE, there is no nobody user. */ -#ifndef __PASE__ - uv_uid_t uid = getuid(); - if (uid == 0) { - struct passwd* pw; - pw = getpwnam("nobody"); - ASSERT_NOT_NULL(pw); - ASSERT_OK(setgid(pw->pw_gid)); - ASSERT_OK(setuid(pw->pw_uid)); - } -#endif /* !__PASE__ */ - init_process_options("spawn_helper1", fail_cb); options.flags |= UV_PROCESS_SETGID; - /* On IBMi PASE, there is no root user. User may grant + /* On IBMi PASE, there is no root user. User may grant * root-like privileges, including setting gid to 0. */ #if defined(__MVS__) || defined(__PASE__) @@ -1586,17 +1421,15 @@ TEST_IMPL(spawn_setgid_fails) { r = uv_spawn(uv_default_loop(), &process, &options); #if defined(__CYGWIN__) || defined(__MVS__) - ASSERT_EQ(r, UV_EINVAL); -#else - ASSERT_EQ(r, UV_EPERM); + ASSERT(r == UV_EINVAL); #endif r = uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_OK(close_cb_called); + ASSERT(close_cb_called == 0); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } #endif @@ -1620,14 +1453,14 @@ TEST_IMPL(spawn_setuid_fails) { options.uid = (uv_uid_t) -42424242; r = uv_spawn(uv_default_loop(), &process, &options); - ASSERT_EQ(r, UV_ENOTSUP); + ASSERT(r == UV_ENOTSUP); r = uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_OK(close_cb_called); + ASSERT(close_cb_called == 0); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -1641,14 +1474,14 @@ TEST_IMPL(spawn_setgid_fails) { options.gid = (uv_gid_t) -42424242; r = uv_spawn(uv_default_loop(), &process, &options); - ASSERT_EQ(r, UV_ENOTSUP); + ASSERT(r == UV_ENOTSUP); r = uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_OK(close_cb_called); + ASSERT(close_cb_called == 0); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } #endif @@ -1656,13 +1489,13 @@ TEST_IMPL(spawn_setgid_fails) { TEST_IMPL(spawn_auto_unref) { init_process_options("spawn_helper1", NULL); - ASSERT_OK(uv_spawn(uv_default_loop(), &process, &options)); - ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT)); - ASSERT_OK(uv_is_closing((uv_handle_t*) &process)); + ASSERT(0 == uv_spawn(uv_default_loop(), &process, &options)); + ASSERT(0 == uv_run(uv_default_loop(), UV_RUN_DEFAULT)); + ASSERT(0 == uv_is_closing((uv_handle_t*) &process)); uv_close((uv_handle_t*) &process, NULL); - ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT)); - ASSERT_EQ(1, uv_is_closing((uv_handle_t*) &process)); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + ASSERT(0 == uv_run(uv_default_loop(), UV_RUN_DEFAULT)); + ASSERT(1 == uv_is_closing((uv_handle_t*) &process)); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -1685,14 +1518,14 @@ TEST_IMPL(spawn_fs_open) { const char dev_null[] = "/dev/null"; #endif - r = uv_fs_open(NULL, &fs_req, dev_null, UV_FS_O_RDWR, 0, NULL); - ASSERT_NE(r, -1); + r = uv_fs_open(NULL, &fs_req, dev_null, O_RDWR, 0, NULL); + ASSERT(r != -1); fd = uv_get_osfhandle((uv_file) fs_req.result); uv_fs_req_cleanup(&fs_req); init_process_options("spawn_helper8", exit_cb); - ASSERT_OK(uv_pipe_init(uv_default_loop(), &in, 0)); + ASSERT(0 == uv_pipe_init(uv_default_loop(), &in, 0)); options.stdio = stdio; options.stdio[0].flags = UV_CREATE_PIPE | UV_READABLE_PIPE; @@ -1701,37 +1534,31 @@ TEST_IMPL(spawn_fs_open) { /* make an inheritable copy */ #ifdef _WIN32 - ASSERT_NE(0, DuplicateHandle(GetCurrentProcess(), fd, GetCurrentProcess(), &dup_fd, - 0, /* inherit */ TRUE, DUPLICATE_SAME_ACCESS)); + ASSERT(0 != DuplicateHandle(GetCurrentProcess(), fd, GetCurrentProcess(), &dup_fd, + 0, /* inherit */ TRUE, DUPLICATE_SAME_ACCESS)); kernelbase_module = GetModuleHandleA("kernelbase.dll"); pCompareObjectHandles = (sCompareObjectHandles) GetProcAddress(kernelbase_module, "CompareObjectHandles"); - ASSERT_NE(pCompareObjectHandles == NULL || - pCompareObjectHandles(fd, dup_fd), - 0); + ASSERT(pCompareObjectHandles == NULL || pCompareObjectHandles(fd, dup_fd)); #else dup_fd = dup(fd); #endif - ASSERT_OK(uv_spawn(uv_default_loop(), &process, &options)); + ASSERT(0 == uv_spawn(uv_default_loop(), &process, &options)); buf = uv_buf_init((char*) &fd, sizeof(fd)); - ASSERT_OK(uv_write(&write_req, - (uv_stream_t*) &in, - &buf, - 1, - write_null_cb)); + ASSERT(0 == uv_write(&write_req, (uv_stream_t*) &in, &buf, 1, write_null_cb)); buf = uv_buf_init((char*) &dup_fd, sizeof(fd)); - ASSERT_OK(uv_write(&write_req2, (uv_stream_t*) &in, &buf, 1, write_cb)); + ASSERT(0 == uv_write(&write_req2, (uv_stream_t*) &in, &buf, 1, write_cb)); - ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT)); - ASSERT_OK(uv_fs_close(NULL, &fs_req, r, NULL)); + ASSERT(0 == uv_run(uv_default_loop(), UV_RUN_DEFAULT)); + ASSERT(0 == uv_fs_close(NULL, &fs_req, r, NULL)); - ASSERT_EQ(1, exit_cb_called); - ASSERT_EQ(2, close_cb_called); /* One for `in`, one for process */ + ASSERT(exit_cb_called == 1); + ASSERT(close_cb_called == 2); /* One for `in`, one for process */ - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -1745,9 +1572,9 @@ TEST_IMPL(closed_fd_events) { bufs[0] = uv_buf_init("", 1); /* create a pipe and share it with a child process */ - ASSERT_OK(uv_pipe(fd, 0, 0)); - ASSERT_GT(fd[0], 2); - ASSERT_GT(fd[1], 2); + ASSERT(0 == uv_pipe(fd, 0, 0)); + ASSERT(fd[0] > 2); + ASSERT(fd[1] > 2); /* spawn_helper4 blocks indefinitely. */ init_process_options("spawn_helper4", exit_cb); @@ -1758,54 +1585,52 @@ TEST_IMPL(closed_fd_events) { options.stdio[1].flags = UV_IGNORE; options.stdio[2].flags = UV_IGNORE; - ASSERT_OK(uv_spawn(uv_default_loop(), &process, &options)); + ASSERT(0 == uv_spawn(uv_default_loop(), &process, &options)); uv_unref((uv_handle_t*) &process); /* read from the pipe with uv */ - ASSERT_OK(uv_pipe_init(uv_default_loop(), &pipe_handle, 0)); - ASSERT_OK(uv_pipe_open(&pipe_handle, fd[0])); + ASSERT(0 == uv_pipe_init(uv_default_loop(), &pipe_handle, 0)); + ASSERT(0 == uv_pipe_open(&pipe_handle, fd[0])); /* uv_pipe_open() takes ownership of the file descriptor. */ fd[0] = -1; - ASSERT_OK(uv_read_start((uv_stream_t*) &pipe_handle, - on_alloc, - on_read_once)); + ASSERT(0 == uv_read_start((uv_stream_t*) &pipe_handle, on_alloc, on_read_once)); - ASSERT_EQ(1, uv_fs_write(NULL, &req, fd[1], bufs, 1, -1, NULL)); - ASSERT_EQ(1, req.result); + ASSERT(1 == uv_fs_write(NULL, &req, fd[1], bufs, 1, -1, NULL)); + ASSERT(req.result == 1); uv_fs_req_cleanup(&req); - ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_ONCE)); + ASSERT(0 == uv_run(uv_default_loop(), UV_RUN_ONCE)); /* should have received just one byte */ - ASSERT_EQ(1, output_used); + ASSERT(output_used == 1); /* close the pipe and see if we still get events */ uv_close((uv_handle_t*) &pipe_handle, close_cb); - ASSERT_EQ(1, uv_fs_write(NULL, &req, fd[1], bufs, 1, -1, NULL)); - ASSERT_EQ(1, req.result); + ASSERT(1 == uv_fs_write(NULL, &req, fd[1], bufs, 1, -1, NULL)); + ASSERT(req.result == 1); uv_fs_req_cleanup(&req); - ASSERT_OK(uv_timer_init(uv_default_loop(), &timer)); - ASSERT_OK(uv_timer_start(&timer, timer_counter_cb, 10, 0)); + ASSERT(0 == uv_timer_init(uv_default_loop(), &timer)); + ASSERT(0 == uv_timer_start(&timer, timer_counter_cb, 10, 0)); /* see if any spurious events interrupt the timer */ if (1 == uv_run(uv_default_loop(), UV_RUN_ONCE)) /* have to run again to really trigger the timer */ - ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_ONCE)); + ASSERT(0 == uv_run(uv_default_loop(), UV_RUN_ONCE)); - ASSERT_EQ(1, timer_counter); + ASSERT(timer_counter == 1); /* cleanup */ - ASSERT_OK(uv_process_kill(&process, SIGTERM)); + ASSERT(0 == uv_process_kill(&process, SIGTERM)); #ifdef _WIN32 - ASSERT_OK(_close(fd[1])); + ASSERT(0 == _close(fd[1])); #else - ASSERT_OK(close(fd[1])); + ASSERT(0 == close(fd[1])); #endif - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -1867,15 +1692,15 @@ TEST_IMPL(spawn_reads_child_path) { options.env = env; r = uv_spawn(uv_default_loop(), &process, &options); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_EQ(1, exit_cb_called); - ASSERT_EQ(1, close_cb_called); + ASSERT(exit_cb_called == 1); + ASSERT(close_cb_called == 1); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -1899,27 +1724,27 @@ TEST_IMPL(spawn_inherit_streams) { init_process_options("spawn_helper9", exit_cb); loop = uv_default_loop(); - ASSERT_OK(uv_pipe_init(loop, &pipe_stdin_child, 0)); - ASSERT_OK(uv_pipe_init(loop, &pipe_stdout_child, 0)); - ASSERT_OK(uv_pipe_init(loop, &pipe_stdin_parent, 0)); - ASSERT_OK(uv_pipe_init(loop, &pipe_stdout_parent, 0)); - - ASSERT_OK(uv_pipe(fds_stdin, 0, 0)); - ASSERT_OK(uv_pipe(fds_stdout, 0, 0)); - - ASSERT_OK(uv_pipe_open(&pipe_stdin_child, fds_stdin[0])); - ASSERT_OK(uv_pipe_open(&pipe_stdout_child, fds_stdout[1])); - ASSERT_OK(uv_pipe_open(&pipe_stdin_parent, fds_stdin[1])); - ASSERT_OK(uv_pipe_open(&pipe_stdout_parent, fds_stdout[0])); + ASSERT(uv_pipe_init(loop, &pipe_stdin_child, 0) == 0); + ASSERT(uv_pipe_init(loop, &pipe_stdout_child, 0) == 0); + ASSERT(uv_pipe_init(loop, &pipe_stdin_parent, 0) == 0); + ASSERT(uv_pipe_init(loop, &pipe_stdout_parent, 0) == 0); + + ASSERT(uv_pipe(fds_stdin, 0, 0) == 0); + ASSERT(uv_pipe(fds_stdout, 0, 0) == 0); + + ASSERT(uv_pipe_open(&pipe_stdin_child, fds_stdin[0]) == 0); + ASSERT(uv_pipe_open(&pipe_stdout_child, fds_stdout[1]) == 0); + ASSERT(uv_pipe_open(&pipe_stdin_parent, fds_stdin[1]) == 0); + ASSERT(uv_pipe_open(&pipe_stdout_parent, fds_stdout[0]) == 0); ASSERT(uv_is_readable((uv_stream_t*) &pipe_stdin_child)); ASSERT(uv_is_writable((uv_stream_t*) &pipe_stdout_child)); ASSERT(uv_is_writable((uv_stream_t*) &pipe_stdin_parent)); ASSERT(uv_is_readable((uv_stream_t*) &pipe_stdout_parent)); /* Some systems (SVR4) open a bidirectional pipe, most don't. */ bidir = uv_is_writable((uv_stream_t*) &pipe_stdin_child); - ASSERT_EQ(uv_is_readable((uv_stream_t*) &pipe_stdout_child), bidir); - ASSERT_EQ(uv_is_readable((uv_stream_t*) &pipe_stdin_parent), bidir); - ASSERT_EQ(uv_is_writable((uv_stream_t*) &pipe_stdout_parent), bidir); + ASSERT(uv_is_readable((uv_stream_t*) &pipe_stdout_child) == bidir); + ASSERT(uv_is_readable((uv_stream_t*) &pipe_stdin_parent) == bidir); + ASSERT(uv_is_writable((uv_stream_t*) &pipe_stdout_parent) == bidir); child_stdio[0].flags = UV_INHERIT_STREAM; child_stdio[0].data.stream = (uv_stream_t *) &pipe_stdin_child; @@ -1930,7 +1755,7 @@ TEST_IMPL(spawn_inherit_streams) { options.stdio = child_stdio; options.stdio_count = 2; - ASSERT_OK(uv_spawn(loop, &child_req, &options)); + ASSERT(uv_spawn(loop, &child_req, &options) == 0); uv_close((uv_handle_t*) &pipe_stdin_child, NULL); uv_close((uv_handle_t*) &pipe_stdout_child, NULL); @@ -1945,21 +1770,21 @@ TEST_IMPL(spawn_inherit_streams) { &buf, 1, write_cb); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_read_start((uv_stream_t*) &pipe_stdout_parent, on_alloc, on_read); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_run(loop, UV_RUN_DEFAULT); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_EQ(1, exit_cb_called); - ASSERT_EQ(3, close_cb_called); + ASSERT(exit_cb_called == 1); + ASSERT(close_cb_called == 3); r = memcmp(ubuf, output, sizeof ubuf); - ASSERT_OK(r); + ASSERT(r == 0); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -1983,7 +1808,7 @@ TEST_IMPL(spawn_quoted_path) { /* We test if libuv will not segfault. */ uv_spawn(uv_default_loop(), &process, &options); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; #endif } @@ -1998,7 +1823,7 @@ TEST_IMPL(spawn_exercise_sigchld_issue) { init_process_options("spawn_helper1", exit_cb); r = uv_spawn(uv_default_loop(), &process, &options); - ASSERT_OK(r); + ASSERT_EQ(r, 0); // This test exercises a bug in the darwin kernel that causes SIGCHLD not to // be delivered sometimes. Calling posix_spawn many times increases the @@ -2017,12 +1842,12 @@ TEST_IMPL(spawn_exercise_sigchld_issue) { } r = uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_OK(r); + ASSERT_EQ(r, 0); - ASSERT_EQ(1, exit_cb_called); - ASSERT_EQ(101, close_cb_called); + ASSERT_EQ(exit_cb_called, 1); + ASSERT_EQ(close_cb_called, 101); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -2039,14 +1864,14 @@ void spawn_stdin_stdout(void) { if (r == 0) { return; } - ASSERT_GT(r, 0); + ASSERT(r > 0); c = r; pbuf = buf; while (c) { do { w = write(1, pbuf, (size_t)c); } while (w == -1 && errno == EINTR); - ASSERT_GE(w, 0); + ASSERT(w >= 0); pbuf = pbuf + w; c = c - w; } @@ -2058,14 +1883,14 @@ void spawn_stdin_stdout(void) { char* pbuf; HANDLE h_stdin = GetStdHandle(STD_INPUT_HANDLE); HANDLE h_stdout = GetStdHandle(STD_OUTPUT_HANDLE); - ASSERT_PTR_NE(h_stdin, INVALID_HANDLE_VALUE); - ASSERT_PTR_NE(h_stdout, INVALID_HANDLE_VALUE); + ASSERT(h_stdin != INVALID_HANDLE_VALUE); + ASSERT(h_stdout != INVALID_HANDLE_VALUE); for (;;) { DWORD n_read; DWORD n_written; DWORD to_write; if (!ReadFile(h_stdin, buf, sizeof buf, &n_read, NULL)) { - ASSERT_EQ(GetLastError(), ERROR_BROKEN_PIPE); + ASSERT(GetLastError() == ERROR_BROKEN_PIPE); return; } to_write = n_read; @@ -2085,7 +1910,7 @@ TEST_IMPL(spawn_relative_path) { init_process_options("spawn_helper1", exit_cb); exepath_size = sizeof(exepath) - 2; - ASSERT_OK(uv_exepath(exepath, &exepath_size)); + ASSERT_EQ(0, uv_exepath(exepath, &exepath_size)); exepath[exepath_size] = '\0'; /* Poor man's basename(3). */ @@ -2103,12 +1928,12 @@ TEST_IMPL(spawn_relative_path) { options.cwd = exepath; options.file = options.args[0] = sep + 1; - ASSERT_OK(uv_spawn(uv_default_loop(), &process, &options)); - ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT)); + ASSERT_EQ(0, uv_spawn(uv_default_loop(), &process, &options)); + ASSERT_EQ(0, uv_run(uv_default_loop(), UV_RUN_DEFAULT)); ASSERT_EQ(1, exit_cb_called); ASSERT_EQ(1, close_cb_called); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-stdio-over-pipes.c b/test/test-stdio-over-pipes.c index c41040e..1aed471 100644 --- a/test/test-stdio-over-pipes.c +++ b/test/test-stdio-over-pipes.c @@ -52,8 +52,8 @@ static void exit_cb(uv_process_t* process, int term_signal) { printf("exit_cb\n"); exit_cb_called++; - ASSERT_OK(exit_status); - ASSERT_OK(term_signal); + ASSERT(exit_status == 0); + ASSERT(term_signal == 0); uv_close((uv_handle_t*)process, close_cb); uv_close((uv_handle_t*)&in, close_cb); uv_close((uv_handle_t*)&out, close_cb); @@ -62,7 +62,7 @@ static void exit_cb(uv_process_t* process, static void init_process_options(char* test, uv_exit_cb exit_cb) { int r = uv_exepath(exepath, &exepath_size); - ASSERT_OK(r); + ASSERT(r == 0); exepath[exepath_size] = '\0'; args[0] = exepath; args[1] = test; @@ -104,11 +104,11 @@ static void on_read(uv_stream_t* pipe, ssize_t nread, const uv_buf_t* rdbuf) { if (nread > 0) { output_used += nread; if (output_used % 12 == 0) { - ASSERT_OK(memcmp("hello world\n", output, 12)); + ASSERT(memcmp("hello world\n", output, 12) == 0); wrbuf = uv_buf_init(output, 12); req = malloc(sizeof(*req)); r = uv_write(req, (uv_stream_t*) &in, &wrbuf, 1, after_write); - ASSERT_OK(r); + ASSERT(r == 0); } } @@ -140,22 +140,22 @@ static void test_stdio_over_pipes(int overlapped) { options.stdio_count = 3; r = uv_spawn(loop, &process, &options); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_read_start((uv_stream_t*) &out, on_alloc, on_read); - ASSERT_OK(r); + ASSERT(r == 0); - r = uv_run(loop, UV_RUN_DEFAULT); - ASSERT_OK(r); + r = uv_run(uv_default_loop(), UV_RUN_DEFAULT); + ASSERT(r == 0); - ASSERT_GT(on_read_cb_called, 1); - ASSERT_EQ(2, after_write_cb_called); - ASSERT_EQ(1, exit_cb_called); - ASSERT_EQ(3, close_cb_called); - ASSERT_OK(memcmp("hello world\nhello world\n", output, 24)); - ASSERT_EQ(24, output_used); + ASSERT(on_read_cb_called > 1); + ASSERT(after_write_cb_called == 2); + ASSERT(exit_cb_called == 1); + ASSERT(close_cb_called == 3); + ASSERT(memcmp("hello world\nhello world\n", output, 24) == 0); + ASSERT(output_used == 24); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); } TEST_IMPL(stdio_over_pipes) { @@ -179,8 +179,8 @@ static uv_pipe_t stdin_pipe2; static uv_pipe_t stdout_pipe2; static void on_pipe_read(uv_stream_t* pipe, ssize_t nread, const uv_buf_t* buf) { - ASSERT_GT(nread, 0); - ASSERT_OK(memcmp("hello world\n", buf->base, nread)); + ASSERT(nread > 0); + ASSERT(memcmp("hello world\n", buf->base, nread) == 0); on_pipe_read_called++; free(buf->base); @@ -190,7 +190,7 @@ static void on_pipe_read(uv_stream_t* pipe, ssize_t nread, const uv_buf_t* buf) static void after_pipe_write(uv_write_t* req, int status) { - ASSERT_OK(status); + ASSERT(status == 0); after_write_called++; } @@ -222,17 +222,17 @@ int stdio_over_pipes_helper(void) { int r; uv_loop_t* loop = uv_default_loop(); - ASSERT_EQ(UV_NAMED_PIPE, uv_guess_handle(0)); - ASSERT_EQ(UV_NAMED_PIPE, uv_guess_handle(1)); + ASSERT(UV_NAMED_PIPE == uv_guess_handle(0)); + ASSERT(UV_NAMED_PIPE == uv_guess_handle(1)); r = uv_pipe_init(loop, &stdin_pipe1, 0); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_pipe_init(loop, &stdout_pipe1, 0); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_pipe_init(loop, &stdin_pipe2, 0); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_pipe_init(loop, &stdout_pipe2, 0); - ASSERT_OK(r); + ASSERT(r == 0); uv_pipe_open(&stdin_pipe1, 0); uv_pipe_open(&stdout_pipe1, 1); @@ -256,15 +256,15 @@ int stdio_over_pipes_helper(void) { &buf[i], 1, after_pipe_write); - ASSERT_OK(r); + ASSERT(r == 0); } notify_parent_process(); uv_run(loop, UV_RUN_DEFAULT); - ASSERT_EQ(after_write_called, 7 * (j + 1)); - ASSERT_EQ(on_pipe_read_called, j); - ASSERT_OK(close_cb_called); + ASSERT(after_write_called == 7 * (j + 1)); + ASSERT(on_pipe_read_called == j); + ASSERT(close_cb_called == 0); uv_ref((uv_handle_t*) &stdout_pipe1); uv_ref((uv_handle_t*) &stdin_pipe1); @@ -274,13 +274,13 @@ int stdio_over_pipes_helper(void) { r = uv_read_start((uv_stream_t*) (j == 0 ? &stdin_pipe1 : &stdin_pipe2), on_read_alloc, on_pipe_read); - ASSERT_OK(r); + ASSERT(r == 0); uv_run(loop, UV_RUN_DEFAULT); - ASSERT_EQ(after_write_called, 7 * (j + 1)); - ASSERT_EQ(on_pipe_read_called, j + 1); - ASSERT_OK(close_cb_called); + ASSERT(after_write_called == 7 * (j + 1)); + ASSERT(on_pipe_read_called == j + 1); + ASSERT(close_cb_called == 0); } uv_close((uv_handle_t*)&stdin_pipe1, close_cb); @@ -290,10 +290,10 @@ int stdio_over_pipes_helper(void) { uv_run(loop, UV_RUN_DEFAULT); - ASSERT_EQ(14, after_write_called); - ASSERT_EQ(2, on_pipe_read_called); - ASSERT_EQ(4, close_cb_called); + ASSERT(after_write_called == 14); + ASSERT(on_pipe_read_called == 2); + ASSERT(close_cb_called == 4); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-strscpy.c b/test/test-strscpy.c index b4699cf..993f7a1 100644 --- a/test/test-strscpy.c +++ b/test/test-strscpy.c @@ -24,30 +24,29 @@ #include #include "../src/strscpy.h" -#include "../src/strscpy.c" TEST_IMPL(strscpy) { char d[4]; - ASSERT_OK(uv__strscpy(d, "", 0)); - ASSERT_OK(uv__strscpy(d, "x", 0)); + ASSERT(0 == uv__strscpy(d, "", 0)); + ASSERT(0 == uv__strscpy(d, "x", 0)); memset(d, 0, sizeof(d)); - ASSERT_EQ(1, uv__strscpy(d, "x", sizeof(d))); - ASSERT_OK(memcmp(d, "x\0\0", sizeof(d))); + ASSERT(1 == uv__strscpy(d, "x", sizeof(d))); + ASSERT(0 == memcmp(d, "x\0\0", sizeof(d))); memset(d, 0, sizeof(d)); - ASSERT_EQ(2, uv__strscpy(d, "xy", sizeof(d))); - ASSERT_OK(memcmp(d, "xy\0", sizeof(d))); + ASSERT(2 == uv__strscpy(d, "xy", sizeof(d))); + ASSERT(0 == memcmp(d, "xy\0", sizeof(d))); - ASSERT_EQ(3, uv__strscpy(d, "xyz", sizeof(d))); - ASSERT_OK(memcmp(d, "xyz", sizeof(d))); + ASSERT(3 == uv__strscpy(d, "xyz", sizeof(d))); + ASSERT(0 == memcmp(d, "xyz", sizeof(d))); - ASSERT_EQ(UV_E2BIG, uv__strscpy(d, "xyzz", sizeof(d))); - ASSERT_OK(memcmp(d, "xyz", sizeof(d))); + ASSERT(UV_E2BIG == uv__strscpy(d, "xyzz", sizeof(d))); + ASSERT(0 == memcmp(d, "xyz", sizeof(d))); - ASSERT_EQ(UV_E2BIG, uv__strscpy(d, "xyzzy", sizeof(d))); - ASSERT_OK(memcmp(d, "xyz", sizeof(d))); + ASSERT(UV_E2BIG == uv__strscpy(d, "xyzzy", sizeof(d))); + ASSERT(0 == memcmp(d, "xyz", sizeof(d))); return 0; } diff --git a/test/test-strtok.c b/test/test-strtok.c index f4e6cdf..507e6db 100644 --- a/test/test-strtok.c +++ b/test/test-strtok.c @@ -56,35 +56,8 @@ const char* tokens[] = { }; #define ASSERT_STRCMP(x, y) \ - ASSERT_NE((x != NULL && y != NULL && strcmp(x, y) == 0) || (x == y && x == NULL), 0) + ASSERT((x != NULL && y != NULL && strcmp(x, y) == 0) || (x == y && x == NULL)) TEST_IMPL(strtok) { - struct strtok_test_case tests[] = { - { "abc", "" }, - { "abc.abf", "." }, - { "This;is.a:test:of=the/string\\tokenizer-function.", "\\/:;=-" }, - { "Hello This-is-a-nice.-string", " ." }, - }; - size_t tokens_len = ARRAY_SIZE(tokens); - size_t tests_len = ARRAY_SIZE(tests); - size_t i; - size_t j; - char* itr; - char* tok_r; - char current_test[2048]; - - for (i = 0, j = 0; i < tests_len; i += 1) { - ASSERT_LT(j, tokens_len); - snprintf(current_test, sizeof(current_test), "%s", tests[i].str); - tok_r = uv__strtok(current_test, tests[i].sep, &itr); - ASSERT_STRCMP(tok_r, tokens[j]); - j++; - while (tok_r) { - ASSERT_LT(j, tokens_len); - tok_r = uv__strtok(NULL, tests[i].sep, &itr); - ASSERT_STRCMP(tok_r, tokens[j]); - j++; - } - } return 0; } diff --git a/test/test-tcp-alloc-cb-fail.c b/test/test-tcp-alloc-cb-fail.c index ff1cfcb..b6f4ca3 100644 --- a/test/test-tcp-alloc-cb-fail.c +++ b/test/test-tcp-alloc-cb-fail.c @@ -42,7 +42,7 @@ static void close_cb(uv_handle_t* handle) { } static void write_cb(uv_write_t* req, int status) { - ASSERT_OK(status); + ASSERT(status == 0); } static void conn_alloc_cb(uv_handle_t* handle, size_t size, uv_buf_t* buf) { @@ -52,9 +52,9 @@ static void conn_alloc_cb(uv_handle_t* handle, size_t size, uv_buf_t* buf) { static void conn_read_cb(uv_stream_t* stream, ssize_t nread, const uv_buf_t* buf) { - ASSERT_EQ(nread, UV_ENOBUFS); + ASSERT(nread == UV_ENOBUFS); ASSERT_NULL(buf->base); - ASSERT_OK(buf->len); + ASSERT(buf->len == 0); uv_close((uv_handle_t*) &incoming, close_cb); uv_close((uv_handle_t*) &client, close_cb); @@ -65,23 +65,23 @@ static void connect_cb(uv_connect_t* req, int status) { int r; uv_buf_t buf; - ASSERT_OK(status); + ASSERT(status == 0); connect_cb_called++; buf = uv_buf_init(hello, sizeof(hello)); r = uv_write(&write_req, req->handle, &buf, 1, write_cb); - ASSERT_OK(r); + ASSERT(r == 0); } static void connection_cb(uv_stream_t* tcp, int status) { - ASSERT_OK(status); + ASSERT(status == 0); - ASSERT_OK(uv_tcp_init(tcp->loop, &incoming)); - ASSERT_OK(uv_accept(tcp, (uv_stream_t*) &incoming)); - ASSERT_OK(uv_read_start((uv_stream_t*) &incoming, - conn_alloc_cb, - conn_read_cb)); + ASSERT(0 == uv_tcp_init(tcp->loop, &incoming)); + ASSERT(0 == uv_accept(tcp, (uv_stream_t*) &incoming)); + ASSERT(0 == uv_read_start((uv_stream_t*) &incoming, + conn_alloc_cb, + conn_read_cb)); connection_cb_called++; } @@ -90,11 +90,11 @@ static void connection_cb(uv_stream_t* tcp, int status) { static void start_server(void) { struct sockaddr_in addr; - ASSERT_OK(uv_ip4_addr("0.0.0.0", TEST_PORT, &addr)); + ASSERT(0 == uv_ip4_addr("0.0.0.0", TEST_PORT, &addr)); - ASSERT_OK(uv_tcp_init(uv_default_loop(), &server)); - ASSERT_OK(uv_tcp_bind(&server, (struct sockaddr*) &addr, 0)); - ASSERT_OK(uv_listen((uv_stream_t*) &server, 128, connection_cb)); + ASSERT(0 == uv_tcp_init(uv_default_loop(), &server)); + ASSERT(0 == uv_tcp_bind(&server, (struct sockaddr*) &addr, 0)); + ASSERT(0 == uv_listen((uv_stream_t*) &server, 128, connection_cb)); } @@ -104,20 +104,20 @@ TEST_IMPL(tcp_alloc_cb_fail) { start_server(); - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); + ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); - ASSERT_OK(uv_tcp_init(uv_default_loop(), &client)); - ASSERT_OK(uv_tcp_connect(&connect_req, - &client, - (struct sockaddr*) &addr, - connect_cb)); + ASSERT(0 == uv_tcp_init(uv_default_loop(), &client)); + ASSERT(0 == uv_tcp_connect(&connect_req, + &client, + (struct sockaddr*) &addr, + connect_cb)); - ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT)); + ASSERT(0 == uv_run(uv_default_loop(), UV_RUN_DEFAULT)); - ASSERT_EQ(1, connect_cb_called); - ASSERT_EQ(1, connection_cb_called); - ASSERT_EQ(3, close_cb_called); + ASSERT(connect_cb_called == 1); + ASSERT(connection_cb_called == 1); + ASSERT(close_cb_called == 3); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-tcp-bind-error.c b/test/test-tcp-bind-error.c index 89e4e33..c3ca6ec 100644 --- a/test/test-tcp-bind-error.c +++ b/test/test-tcp-bind-error.c @@ -36,7 +36,7 @@ static void close_cb(uv_handle_t* handle) { static void connect_cb(uv_connect_t* req, int status) { - ASSERT_EQ(status, UV_EADDRINUSE); + ASSERT(status == UV_EADDRINUSE); uv_close((uv_handle_t*) req->handle, close_cb); connect_cb_called++; } @@ -53,26 +53,26 @@ TEST_IMPL(tcp_bind_error_addrinuse_connect) { * (greatest common denominator across platforms) but the connect callback * should receive an UV_EADDRINUSE error. */ - ASSERT_OK(uv_tcp_init(uv_default_loop(), &conn)); - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); - ASSERT_OK(uv_tcp_bind(&conn, (const struct sockaddr*) &addr, 0)); + ASSERT(0 == uv_tcp_init(uv_default_loop(), &conn)); + ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); + ASSERT(0 == uv_tcp_bind(&conn, (const struct sockaddr*) &addr, 0)); - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT + 1, &addr)); - ASSERT_OK(uv_tcp_connect(&req, - &conn, - (const struct sockaddr*) &addr, - connect_cb)); + ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT + 1, &addr)); + ASSERT(0 == uv_tcp_connect(&req, + &conn, + (const struct sockaddr*) &addr, + connect_cb)); addrlen = sizeof(addr); - ASSERT_EQ(UV_EADDRINUSE, uv_tcp_getsockname(&conn, - (struct sockaddr*) &addr, - &addrlen)); + ASSERT(UV_EADDRINUSE == uv_tcp_getsockname(&conn, + (struct sockaddr*) &addr, + &addrlen)); - ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT)); - ASSERT_EQ(1, connect_cb_called); - ASSERT_EQ(1, close_cb_called); + ASSERT(0 == uv_run(uv_default_loop(), UV_RUN_DEFAULT)); + ASSERT(connect_cb_called == 1); + ASSERT(close_cb_called == 1); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -82,30 +82,30 @@ TEST_IMPL(tcp_bind_error_addrinuse_listen) { uv_tcp_t server1, server2; int r; - ASSERT_OK(uv_ip4_addr("0.0.0.0", TEST_PORT, &addr)); + ASSERT(0 == uv_ip4_addr("0.0.0.0", TEST_PORT, &addr)); r = uv_tcp_init(uv_default_loop(), &server1); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_tcp_bind(&server1, (const struct sockaddr*) &addr, 0); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_tcp_init(uv_default_loop(), &server2); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_tcp_bind(&server2, (const struct sockaddr*) &addr, 0); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_listen((uv_stream_t*)&server1, 128, NULL); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_listen((uv_stream_t*)&server2, 128, NULL); - ASSERT_EQ(r, UV_EADDRINUSE); + ASSERT(r == UV_EADDRINUSE); uv_close((uv_handle_t*)&server1, close_cb); uv_close((uv_handle_t*)&server2, close_cb); uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_EQ(2, close_cb_called); + ASSERT(close_cb_called == 2); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -115,10 +115,10 @@ TEST_IMPL(tcp_bind_error_addrnotavail_1) { uv_tcp_t server; int r; - ASSERT_OK(uv_ip4_addr("127.255.255.255", TEST_PORT, &addr)); + ASSERT(0 == uv_ip4_addr("127.255.255.255", TEST_PORT, &addr)); r = uv_tcp_init(uv_default_loop(), &server); - ASSERT_OK(r); + ASSERT(r == 0); /* It seems that Linux is broken here - bind succeeds. */ r = uv_tcp_bind(&server, (const struct sockaddr*) &addr, 0); @@ -128,9 +128,9 @@ TEST_IMPL(tcp_bind_error_addrnotavail_1) { uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_EQ(1, close_cb_called); + ASSERT(close_cb_called == 1); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -140,20 +140,20 @@ TEST_IMPL(tcp_bind_error_addrnotavail_2) { uv_tcp_t server; int r; - ASSERT_OK(uv_ip4_addr("4.4.4.4", TEST_PORT, &addr)); + ASSERT(0 == uv_ip4_addr("4.4.4.4", TEST_PORT, &addr)); r = uv_tcp_init(uv_default_loop(), &server); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_tcp_bind(&server, (const struct sockaddr*) &addr, 0); - ASSERT_EQ(r, UV_EADDRNOTAVAIL); + ASSERT(r == UV_EADDRNOTAVAIL); uv_close((uv_handle_t*)&server, close_cb); uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_EQ(1, close_cb_called); + ASSERT(close_cb_called == 1); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -168,17 +168,17 @@ TEST_IMPL(tcp_bind_error_fault) { garbage_addr = (struct sockaddr_in*) &garbage; r = uv_tcp_init(uv_default_loop(), &server); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_tcp_bind(&server, (const struct sockaddr*) garbage_addr, 0); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); uv_close((uv_handle_t*)&server, close_cb); uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_EQ(1, close_cb_called); + ASSERT(close_cb_called == 1); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -190,23 +190,23 @@ TEST_IMPL(tcp_bind_error_inval) { uv_tcp_t server; int r; - ASSERT_OK(uv_ip4_addr("0.0.0.0", TEST_PORT, &addr1)); - ASSERT_OK(uv_ip4_addr("0.0.0.0", TEST_PORT_2, &addr2)); + ASSERT(0 == uv_ip4_addr("0.0.0.0", TEST_PORT, &addr1)); + ASSERT(0 == uv_ip4_addr("0.0.0.0", TEST_PORT_2, &addr2)); r = uv_tcp_init(uv_default_loop(), &server); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_tcp_bind(&server, (const struct sockaddr*) &addr1, 0); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_tcp_bind(&server, (const struct sockaddr*) &addr2, 0); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); uv_close((uv_handle_t*)&server, close_cb); uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_EQ(1, close_cb_called); + ASSERT(close_cb_called == 1); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -216,14 +216,14 @@ TEST_IMPL(tcp_bind_localhost_ok) { uv_tcp_t server; int r; - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); + ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); r = uv_tcp_init(uv_default_loop(), &server); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_tcp_bind(&server, (const struct sockaddr*) &addr, 0); - ASSERT_OK(r); + ASSERT(r == 0); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -233,14 +233,14 @@ TEST_IMPL(tcp_bind_invalid_flags) { uv_tcp_t server; int r; - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); + ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); r = uv_tcp_init(uv_default_loop(), &server); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_tcp_bind(&server, (const struct sockaddr*) &addr, UV_TCP_IPV6ONLY); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -250,11 +250,11 @@ TEST_IMPL(tcp_listen_without_bind) { uv_tcp_t server; r = uv_tcp_init(uv_default_loop(), &server); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_listen((uv_stream_t*)&server, 128, NULL); - ASSERT_OK(r); + ASSERT(r == 0); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -267,34 +267,34 @@ TEST_IMPL(tcp_bind_writable_flags) { uv_shutdown_t shutdown_req; int r; - ASSERT_OK(uv_ip4_addr("0.0.0.0", TEST_PORT, &addr)); + ASSERT(0 == uv_ip4_addr("0.0.0.0", TEST_PORT, &addr)); r = uv_tcp_init(uv_default_loop(), &server); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_tcp_bind(&server, (const struct sockaddr*) &addr, 0); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_listen((uv_stream_t*)&server, 128, NULL); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_OK(uv_is_writable((uv_stream_t*) &server)); - ASSERT_OK(uv_is_readable((uv_stream_t*) &server)); + ASSERT(0 == uv_is_writable((uv_stream_t*) &server)); + ASSERT(0 == uv_is_readable((uv_stream_t*) &server)); buf = uv_buf_init("PING", 4); r = uv_write(&write_req, (uv_stream_t*) &server, &buf, 1, NULL); - ASSERT_EQ(r, UV_EPIPE); + ASSERT(r == UV_EPIPE); r = uv_shutdown(&shutdown_req, (uv_stream_t*) &server, NULL); - ASSERT_EQ(r, UV_ENOTCONN); + ASSERT(r == UV_ENOTCONN); r = uv_read_start((uv_stream_t*) &server, (uv_alloc_cb) abort, (uv_read_cb) abort); - ASSERT_EQ(r, UV_ENOTCONN); + ASSERT(r == UV_ENOTCONN); uv_close((uv_handle_t*)&server, close_cb); uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_EQ(1, close_cb_called); + ASSERT(close_cb_called == 1); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -307,11 +307,11 @@ TEST_IMPL(tcp_bind_or_listen_error_after_close) { addr.sin_port = htons(9999); addr.sin_family = AF_INET; - ASSERT_OK(uv_tcp_init(uv_default_loop(), &tcp)); + ASSERT_EQ(uv_tcp_init(uv_default_loop(), &tcp), 0); uv_close((uv_handle_t*) &tcp, NULL); ASSERT_EQ(uv_tcp_bind(&tcp, (struct sockaddr*) &addr, 0), UV_EINVAL); ASSERT_EQ(uv_listen((uv_stream_t*) &tcp, 5, NULL), UV_EINVAL); - ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT)); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + ASSERT_EQ(uv_run(uv_default_loop(), UV_RUN_DEFAULT), 0); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-tcp-bind6-error.c b/test/test-tcp-bind6-error.c index f44d3b7..86181b7 100644 --- a/test/test-tcp-bind6-error.c +++ b/test/test-tcp-bind6-error.c @@ -42,31 +42,31 @@ TEST_IMPL(tcp_bind6_error_addrinuse) { if (!can_ipv6()) RETURN_SKIP("IPv6 not supported"); - ASSERT_OK(uv_ip6_addr("::", TEST_PORT, &addr)); + ASSERT(0 == uv_ip6_addr("::", TEST_PORT, &addr)); r = uv_tcp_init(uv_default_loop(), &server1); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_tcp_bind(&server1, (const struct sockaddr*) &addr, 0); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_tcp_init(uv_default_loop(), &server2); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_tcp_bind(&server2, (const struct sockaddr*) &addr, 0); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_listen((uv_stream_t*)&server1, 128, NULL); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_listen((uv_stream_t*)&server2, 128, NULL); - ASSERT_EQ(r, UV_EADDRINUSE); + ASSERT(r == UV_EADDRINUSE); uv_close((uv_handle_t*)&server1, close_cb); uv_close((uv_handle_t*)&server2, close_cb); uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_EQ(2, close_cb_called); + ASSERT(close_cb_called == 2); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -79,20 +79,20 @@ TEST_IMPL(tcp_bind6_error_addrnotavail) { if (!can_ipv6()) RETURN_SKIP("IPv6 not supported"); - ASSERT_OK(uv_ip6_addr("4:4:4:4:4:4:4:4", TEST_PORT, &addr)); + ASSERT(0 == uv_ip6_addr("4:4:4:4:4:4:4:4", TEST_PORT, &addr)); r = uv_tcp_init(uv_default_loop(), &server); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_tcp_bind(&server, (const struct sockaddr*) &addr, 0); - ASSERT_EQ(r, UV_EADDRNOTAVAIL); + ASSERT(r == UV_EADDRNOTAVAIL); uv_close((uv_handle_t*)&server, close_cb); uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_EQ(1, close_cb_called); + ASSERT(close_cb_called == 1); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -110,17 +110,17 @@ TEST_IMPL(tcp_bind6_error_fault) { garbage_addr = (struct sockaddr_in6*) &garbage; r = uv_tcp_init(uv_default_loop(), &server); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_tcp_bind(&server, (const struct sockaddr*) garbage_addr, 0); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); uv_close((uv_handle_t*)&server, close_cb); uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_EQ(1, close_cb_called); + ASSERT(close_cb_called == 1); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -135,23 +135,23 @@ TEST_IMPL(tcp_bind6_error_inval) { if (!can_ipv6()) RETURN_SKIP("IPv6 not supported"); - ASSERT_OK(uv_ip6_addr("::", TEST_PORT, &addr1)); - ASSERT_OK(uv_ip6_addr("::", TEST_PORT_2, &addr2)); + ASSERT(0 == uv_ip6_addr("::", TEST_PORT, &addr1)); + ASSERT(0 == uv_ip6_addr("::", TEST_PORT_2, &addr2)); r = uv_tcp_init(uv_default_loop(), &server); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_tcp_bind(&server, (const struct sockaddr*) &addr1, 0); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_tcp_bind(&server, (const struct sockaddr*) &addr2, 0); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); uv_close((uv_handle_t*)&server, close_cb); uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_EQ(1, close_cb_called); + ASSERT(close_cb_called == 1); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -164,13 +164,13 @@ TEST_IMPL(tcp_bind6_localhost_ok) { if (!can_ipv6()) RETURN_SKIP("IPv6 not supported"); - ASSERT_OK(uv_ip6_addr("::1", TEST_PORT, &addr)); + ASSERT(0 == uv_ip6_addr("::1", TEST_PORT, &addr)); r = uv_tcp_init(uv_default_loop(), &server); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_tcp_bind(&server, (const struct sockaddr*) &addr, 0); - ASSERT_OK(r); + ASSERT(r == 0); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-tcp-close-accept.c b/test/test-tcp-close-accept.c index 4988dd1..624262b 100644 --- a/test/test-tcp-close-accept.c +++ b/test/test-tcp-close-accept.c @@ -47,7 +47,7 @@ static void close_cb(uv_handle_t* handle) { } static void write_cb(uv_write_t* req, int status) { - ASSERT_OK(status); + ASSERT(status == 0); write_cb_called++; } @@ -57,7 +57,7 @@ static void connect_cb(uv_connect_t* req, int status) { uv_stream_t* outgoing; if (req == &tcp_check_req) { - ASSERT(status); + ASSERT(status != 0); /* * Time to finish the test: close both the check and pending incoming @@ -68,14 +68,14 @@ static void connect_cb(uv_connect_t* req, int status) { return; } - ASSERT_OK(status); - ASSERT_LE(connect_reqs, req); - ASSERT_LE(req, connect_reqs + ARRAY_SIZE(connect_reqs)); + ASSERT(status == 0); + ASSERT(connect_reqs <= req); + ASSERT(req <= connect_reqs + ARRAY_SIZE(connect_reqs)); i = req - connect_reqs; buf = uv_buf_init("x", 1); outgoing = (uv_stream_t*) &tcp_outgoing[i]; - ASSERT_OK(uv_write(&write_reqs[i], outgoing, &buf, 1, write_cb)); + ASSERT(0 == uv_write(&write_reqs[i], outgoing, &buf, 1, write_cb)); } static void alloc_cb(uv_handle_t* handle, size_t size, uv_buf_t* buf) { @@ -89,9 +89,9 @@ static void read_cb(uv_stream_t* stream, ssize_t nread, const uv_buf_t* buf) { unsigned int i; pending_incoming = (uv_tcp_t*) stream - &tcp_incoming[0]; - ASSERT_LT(pending_incoming, got_connections); - ASSERT_OK(uv_read_stop(stream)); - ASSERT_EQ(1, nread); + ASSERT(pending_incoming < got_connections); + ASSERT(0 == uv_read_stop(stream)); + ASSERT(1 == nread); loop = stream->loop; read_cb_called++; @@ -106,19 +106,19 @@ static void read_cb(uv_stream_t* stream, ssize_t nread, const uv_buf_t* buf) { uv_close((uv_handle_t*) &tcp_server, close_cb); /* Create new fd that should be one of the closed incomings */ - ASSERT_OK(uv_tcp_init(loop, &tcp_check)); - ASSERT_OK(uv_tcp_connect(&tcp_check_req, - &tcp_check, - (const struct sockaddr*) &addr, - connect_cb)); - ASSERT_OK(uv_read_start((uv_stream_t*) &tcp_check, alloc_cb, read_cb)); + ASSERT(0 == uv_tcp_init(loop, &tcp_check)); + ASSERT(0 == uv_tcp_connect(&tcp_check_req, + &tcp_check, + (const struct sockaddr*) &addr, + connect_cb)); + ASSERT(0 == uv_read_start((uv_stream_t*) &tcp_check, alloc_cb, read_cb)); } static void connection_cb(uv_stream_t* server, int status) { unsigned int i; uv_tcp_t* incoming; - ASSERT_PTR_EQ(server, (uv_stream_t*) &tcp_server); + ASSERT(server == (uv_stream_t*) &tcp_server); /* Ignore tcp_check connection */ if (got_connections == ARRAY_SIZE(tcp_incoming)) @@ -126,8 +126,8 @@ static void connection_cb(uv_stream_t* server, int status) { /* Accept everyone */ incoming = &tcp_incoming[got_connections++]; - ASSERT_OK(uv_tcp_init(server->loop, incoming)); - ASSERT_OK(uv_accept(server, (uv_stream_t*) incoming)); + ASSERT(0 == uv_tcp_init(server->loop, incoming)); + ASSERT(0 == uv_accept(server, (uv_stream_t*) incoming)); if (got_connections != ARRAY_SIZE(tcp_incoming)) return; @@ -135,7 +135,7 @@ static void connection_cb(uv_stream_t* server, int status) { /* Once all clients are accepted - start reading */ for (i = 0; i < ARRAY_SIZE(tcp_incoming); i++) { incoming = &tcp_incoming[i]; - ASSERT_OK(uv_read_start((uv_stream_t*) incoming, alloc_cb, read_cb)); + ASSERT(0 == uv_read_start((uv_stream_t*) incoming, alloc_cb, read_cb)); } } @@ -162,32 +162,32 @@ TEST_IMPL(tcp_close_accept) { */ loop = uv_default_loop(); - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); + ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); - ASSERT_OK(uv_tcp_init(loop, &tcp_server)); - ASSERT_OK(uv_tcp_bind(&tcp_server, (const struct sockaddr*) &addr, 0)); - ASSERT_OK(uv_listen((uv_stream_t*) &tcp_server, - ARRAY_SIZE(tcp_outgoing), - connection_cb)); + ASSERT(0 == uv_tcp_init(loop, &tcp_server)); + ASSERT(0 == uv_tcp_bind(&tcp_server, (const struct sockaddr*) &addr, 0)); + ASSERT(0 == uv_listen((uv_stream_t*) &tcp_server, + ARRAY_SIZE(tcp_outgoing), + connection_cb)); for (i = 0; i < ARRAY_SIZE(tcp_outgoing); i++) { client = tcp_outgoing + i; - ASSERT_OK(uv_tcp_init(loop, client)); - ASSERT_OK(uv_tcp_connect(&connect_reqs[i], - client, - (const struct sockaddr*) &addr, - connect_cb)); + ASSERT(0 == uv_tcp_init(loop, client)); + ASSERT(0 == uv_tcp_connect(&connect_reqs[i], + client, + (const struct sockaddr*) &addr, + connect_cb)); } uv_run(loop, UV_RUN_DEFAULT); - ASSERT_EQ(ARRAY_SIZE(tcp_outgoing), got_connections); - ASSERT_EQ((ARRAY_SIZE(tcp_outgoing) + 2), close_cb_called); - ASSERT_EQ(ARRAY_SIZE(tcp_outgoing), write_cb_called); - ASSERT_EQ(1, read_cb_called); + ASSERT(ARRAY_SIZE(tcp_outgoing) == got_connections); + ASSERT((ARRAY_SIZE(tcp_outgoing) + 2) == close_cb_called); + ASSERT(ARRAY_SIZE(tcp_outgoing) == write_cb_called); + ASSERT(1 == read_cb_called); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-tcp-close-after-read-timeout.c b/test/test-tcp-close-after-read-timeout.c index 1b81630..493492d 100644 --- a/test/test-tcp-close-after-read-timeout.c +++ b/test/test-tcp-close-after-read-timeout.c @@ -48,10 +48,10 @@ static void on_client_connect(uv_connect_t* conn_req, int status) { int r; r = uv_read_start((uv_stream_t*) &client, on_client_alloc, on_client_read); - ASSERT_OK(r); + ASSERT_EQ(r, 0); r = uv_timer_start(&timer, on_client_timeout, 1000, 0); - ASSERT_OK(r); + ASSERT_EQ(r, 0); } @@ -72,8 +72,8 @@ static void on_client_read(uv_stream_t* stream, ssize_t nread, static void on_client_timeout(uv_timer_t* handle) { - ASSERT_PTR_EQ(handle, &timer); - ASSERT_OK(read_cb_called); + ASSERT_EQ(handle, &timer); + ASSERT_EQ(read_cb_called, 0); uv_read_stop((uv_stream_t*) &client); uv_close((uv_handle_t*) &client, on_close); uv_close((uv_handle_t*) &timer, on_close); @@ -101,20 +101,20 @@ static void on_connection_read(uv_stream_t* stream, static void on_connection(uv_stream_t* server, int status) { int r; - ASSERT_OK(status); - ASSERT_OK(uv_accept(server, (uv_stream_t*) &connection)); + ASSERT_EQ(status, 0); + ASSERT_EQ(uv_accept(server, (uv_stream_t*) &connection), 0); r = uv_read_start((uv_stream_t*) &connection, on_connection_alloc, on_connection_read); - ASSERT_OK(r); + ASSERT_EQ(r, 0); } static void on_close(uv_handle_t* handle) { - ASSERT_NE(handle == (uv_handle_t*) &client || - handle == (uv_handle_t*) &connection || - handle == (uv_handle_t*) &timer, 0); + ASSERT(handle == (uv_handle_t*) &client || + handle == (uv_handle_t*) &connection || + handle == (uv_handle_t*) &timer); on_close_called++; } @@ -123,16 +123,16 @@ static void start_server(uv_loop_t* loop, uv_tcp_t* handle) { struct sockaddr_in addr; int r; - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); + ASSERT_EQ(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr), 0); r = uv_tcp_init(loop, handle); - ASSERT_OK(r); + ASSERT_EQ(r, 0); r = uv_tcp_bind(handle, (const struct sockaddr*) &addr, 0); - ASSERT_OK(r); + ASSERT_EQ(r, 0); r = uv_listen((uv_stream_t*) handle, 128, on_connection); - ASSERT_OK(r); + ASSERT_EQ(r, 0); uv_unref((uv_handle_t*) handle); } @@ -147,7 +147,7 @@ TEST_IMPL(tcp_close_after_read_timeout) { uv_loop_t* loop; int r; - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); + ASSERT_EQ(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr), 0); loop = uv_default_loop(); @@ -155,29 +155,29 @@ TEST_IMPL(tcp_close_after_read_timeout) { start_server(loop, &tcp_server); r = uv_tcp_init(loop, &client); - ASSERT_OK(r); + ASSERT_EQ(r, 0); r = uv_tcp_connect(&connect_req, &client, (const struct sockaddr*) &addr, on_client_connect); - ASSERT_OK(r); + ASSERT_EQ(r, 0); r = uv_tcp_init(loop, &connection); - ASSERT_OK(r); + ASSERT_EQ(r, 0); r = uv_timer_init(loop, &timer); - ASSERT_OK(r); + ASSERT_EQ(r, 0); - ASSERT_OK(read_cb_called); - ASSERT_OK(on_close_called); + ASSERT_EQ(read_cb_called, 0); + ASSERT_EQ(on_close_called, 0); r = uv_run(loop, UV_RUN_DEFAULT); - ASSERT_OK(r); + ASSERT_EQ(r, 0); - ASSERT_EQ(1, read_cb_called); - ASSERT_EQ(3, on_close_called); + ASSERT_EQ(read_cb_called, 1); + ASSERT_EQ(on_close_called, 3); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-tcp-close-reset.c b/test/test-tcp-close-reset.c index 7494178..66dfc82 100644 --- a/test/test-tcp-close-reset.c +++ b/test/test-tcp-close-reset.c @@ -62,7 +62,7 @@ static void do_write(uv_tcp_t* handle) { buf = uv_buf_init("PING", 4); for (i = 0; i < ARRAY_SIZE(write_reqs); i++) { r = uv_write(&write_reqs[i], (uv_stream_t*) handle, &buf, 1, write_cb); - ASSERT_OK(r); + ASSERT(r == 0); } } @@ -72,25 +72,21 @@ static void do_close(uv_tcp_t* handle) { int r; if (shutdown_before_close == 1) { - ASSERT_OK(uv_shutdown(&shutdown_req, - (uv_stream_t*) handle, - shutdown_cb)); - ASSERT_EQ(UV_EINVAL, uv_tcp_close_reset(handle, close_cb)); + ASSERT(0 == uv_shutdown(&shutdown_req, (uv_stream_t*) handle, shutdown_cb)); + ASSERT(UV_EINVAL == uv_tcp_close_reset(handle, close_cb)); } else if (shutdown_before_close == 2) { r = uv_fileno((const uv_handle_t*) handle, &fd); - ASSERT_OK(r); + ASSERT_EQ(r, 0); + ASSERT_NE(fd, INVALID_FD); #ifdef _WIN32 - ASSERT_PTR_NE(fd, INVALID_FD); - ASSERT_OK(shutdown((SOCKET)fd, SD_BOTH)); + ASSERT_EQ(0, shutdown(fd, SD_BOTH)); #else - ASSERT_NE(fd, INVALID_FD); - ASSERT_OK(shutdown(fd, SHUT_RDWR)); + ASSERT_EQ(0, shutdown(fd, SHUT_RDWR)); #endif - ASSERT_OK(uv_tcp_close_reset(handle, close_cb)); + ASSERT_EQ(0, uv_tcp_close_reset(handle, close_cb)); } else { - ASSERT_OK(uv_tcp_close_reset(handle, close_cb)); - ASSERT_EQ(UV_ENOTCONN, uv_shutdown(&shutdown_req, (uv_stream_t*) handle, - shutdown_cb)); + ASSERT(0 == uv_tcp_close_reset(handle, close_cb)); + ASSERT(UV_ENOTCONN == uv_shutdown(&shutdown_req, (uv_stream_t*) handle, shutdown_cb)); } uv_close((uv_handle_t*) &tcp_server, NULL); @@ -103,14 +99,14 @@ static void alloc_cb(uv_handle_t* handle, size_t size, uv_buf_t* buf) { } static void read_cb2(uv_stream_t* stream, ssize_t nread, const uv_buf_t* buf) { - ASSERT_PTR_EQ((uv_tcp_t*)stream, &tcp_client); + ASSERT((uv_tcp_t*)stream == &tcp_client); if (nread == UV_EOF) uv_close((uv_handle_t*) stream, NULL); } static void connect_cb(uv_connect_t* conn_req, int status) { - ASSERT_PTR_EQ(conn_req, &connect_req); + ASSERT(conn_req == &connect_req); uv_read_start((uv_stream_t*) &tcp_client, alloc_cb, read_cb2); do_write(&tcp_client); if (client_close) @@ -120,33 +116,33 @@ static void connect_cb(uv_connect_t* conn_req, int status) { static void write_cb(uv_write_t* req, int status) { /* write callbacks should run before the close callback */ - ASSERT_OK(close_cb_called); - ASSERT_PTR_EQ(req->handle, (uv_stream_t*)&tcp_client); + ASSERT(close_cb_called == 0); + ASSERT(req->handle == (uv_stream_t*)&tcp_client); write_cb_called++; } static void close_cb(uv_handle_t* handle) { if (client_close) - ASSERT_PTR_EQ(handle, (uv_handle_t*) &tcp_client); + ASSERT(handle == (uv_handle_t*) &tcp_client); else - ASSERT_PTR_EQ(handle, (uv_handle_t*) &tcp_accepted); + ASSERT(handle == (uv_handle_t*) &tcp_accepted); close_cb_called++; } static void shutdown_cb(uv_shutdown_t* req, int status) { if (client_close) - ASSERT_PTR_EQ(req->handle, (uv_stream_t*) &tcp_client); + ASSERT(req->handle == (uv_stream_t*) &tcp_client); else - ASSERT_PTR_EQ(req->handle, (uv_stream_t*) &tcp_accepted); + ASSERT(req->handle == (uv_stream_t*) &tcp_accepted); shutdown_cb_called++; } static void read_cb(uv_stream_t* stream, ssize_t nread, const uv_buf_t* buf) { - ASSERT_PTR_EQ((uv_tcp_t*)stream, &tcp_accepted); + ASSERT((uv_tcp_t*)stream == &tcp_accepted); if (nread < 0) { uv_close((uv_handle_t*) stream, NULL); } else { @@ -158,10 +154,10 @@ static void read_cb(uv_stream_t* stream, ssize_t nread, const uv_buf_t* buf) { static void connection_cb(uv_stream_t* server, int status) { - ASSERT_OK(status); + ASSERT(status == 0); - ASSERT_OK(uv_tcp_init(loop, &tcp_accepted)); - ASSERT_OK(uv_accept(server, (uv_stream_t*) &tcp_accepted)); + ASSERT(0 == uv_tcp_init(loop, &tcp_accepted)); + ASSERT(0 == uv_accept(server, (uv_stream_t*) &tcp_accepted)); uv_read_start((uv_stream_t*) &tcp_accepted, alloc_cb, read_cb); } @@ -171,16 +167,16 @@ static void start_server(uv_loop_t* loop, uv_tcp_t* handle) { struct sockaddr_in addr; int r; - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); + ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); r = uv_tcp_init(loop, handle); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_tcp_bind(handle, (const struct sockaddr*) &addr, 0); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_listen((uv_stream_t*)handle, 128, connection_cb); - ASSERT_OK(r); + ASSERT(r == 0); } @@ -188,16 +184,16 @@ static void do_connect(uv_loop_t* loop, uv_tcp_t* tcp_client) { struct sockaddr_in addr; int r; - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); + ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); r = uv_tcp_init(loop, tcp_client); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_tcp_connect(&connect_req, tcp_client, (const struct sockaddr*) &addr, connect_cb); - ASSERT_OK(r); + ASSERT(r == 0); } @@ -216,18 +212,18 @@ TEST_IMPL(tcp_close_reset_client) { do_connect(loop, &tcp_client); - ASSERT_OK(write_cb_called); - ASSERT_OK(close_cb_called); - ASSERT_OK(shutdown_cb_called); + ASSERT(write_cb_called == 0); + ASSERT(close_cb_called == 0); + ASSERT(shutdown_cb_called == 0); r = uv_run(loop, UV_RUN_DEFAULT); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_EQ(4, write_cb_called); - ASSERT_EQ(1, close_cb_called); - ASSERT_OK(shutdown_cb_called); + ASSERT(write_cb_called == 4); + ASSERT(close_cb_called == 1); + ASSERT(shutdown_cb_called == 0); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -243,18 +239,18 @@ TEST_IMPL(tcp_close_reset_client_after_shutdown) { do_connect(loop, &tcp_client); - ASSERT_OK(write_cb_called); - ASSERT_OK(close_cb_called); - ASSERT_OK(shutdown_cb_called); + ASSERT(write_cb_called == 0); + ASSERT(close_cb_called == 0); + ASSERT(shutdown_cb_called == 0); r = uv_run(loop, UV_RUN_DEFAULT); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_EQ(4, write_cb_called); - ASSERT_OK(close_cb_called); - ASSERT_EQ(1, shutdown_cb_called); + ASSERT(write_cb_called == 4); + ASSERT(close_cb_called == 0); + ASSERT(shutdown_cb_called == 1); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -270,18 +266,18 @@ TEST_IMPL(tcp_close_reset_accepted) { do_connect(loop, &tcp_client); - ASSERT_OK(write_cb_called); - ASSERT_OK(close_cb_called); - ASSERT_OK(shutdown_cb_called); + ASSERT(write_cb_called == 0); + ASSERT(close_cb_called == 0); + ASSERT(shutdown_cb_called == 0); r = uv_run(loop, UV_RUN_DEFAULT); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_EQ(4, write_cb_called); - ASSERT_EQ(1, close_cb_called); - ASSERT_OK(shutdown_cb_called); + ASSERT(write_cb_called == 4); + ASSERT(close_cb_called == 1); + ASSERT(shutdown_cb_called == 0); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -297,18 +293,18 @@ TEST_IMPL(tcp_close_reset_accepted_after_shutdown) { do_connect(loop, &tcp_client); - ASSERT_OK(write_cb_called); - ASSERT_OK(close_cb_called); - ASSERT_OK(shutdown_cb_called); + ASSERT(write_cb_called == 0); + ASSERT(close_cb_called == 0); + ASSERT(shutdown_cb_called == 0); r = uv_run(loop, UV_RUN_DEFAULT); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_EQ(4, write_cb_called); - ASSERT_OK(close_cb_called); - ASSERT_EQ(1, shutdown_cb_called); + ASSERT(write_cb_called == 4); + ASSERT(close_cb_called == 0); + ASSERT(shutdown_cb_called == 1); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -324,17 +320,17 @@ TEST_IMPL(tcp_close_reset_accepted_after_socket_shutdown) { do_connect(loop, &tcp_client); - ASSERT_OK(write_cb_called); - ASSERT_OK(close_cb_called); - ASSERT_OK(shutdown_cb_called); + ASSERT_EQ(write_cb_called, 0); + ASSERT_EQ(close_cb_called, 0); + ASSERT_EQ(shutdown_cb_called, 0); r = uv_run(loop, UV_RUN_DEFAULT); - ASSERT_OK(r); + ASSERT_EQ(r, 0); - ASSERT_EQ(4, write_cb_called); - ASSERT_EQ(1, close_cb_called); - ASSERT_OK(shutdown_cb_called); + ASSERT_EQ(write_cb_called, 4); + ASSERT_EQ(close_cb_called, 1); + ASSERT_EQ(shutdown_cb_called, 0); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-tcp-close-while-connecting.c b/test/test-tcp-close-while-connecting.c index ba5e469..8d0b827 100644 --- a/test/test-tcp-close-while-connecting.c +++ b/test/test-tcp-close-while-connecting.c @@ -69,26 +69,26 @@ TEST_IMPL(tcp_close_while_connecting) { int r; loop = uv_default_loop(); - ASSERT_OK(uv_ip4_addr("1.2.3.4", TEST_PORT, &addr)); - ASSERT_OK(uv_tcp_init(loop, &tcp_handle)); + ASSERT(0 == uv_ip4_addr("1.2.3.4", TEST_PORT, &addr)); + ASSERT(0 == uv_tcp_init(loop, &tcp_handle)); r = uv_tcp_connect(&connect_req, &tcp_handle, (const struct sockaddr*) &addr, connect_cb); if (r == UV_ENETUNREACH) RETURN_SKIP("Network unreachable."); - ASSERT_OK(r); - ASSERT_OK(uv_timer_init(loop, &timer1_handle)); - ASSERT_OK(uv_timer_start(&timer1_handle, timer1_cb, 1, 0)); - ASSERT_OK(uv_timer_init(loop, &timer2_handle)); - ASSERT_OK(uv_timer_start(&timer2_handle, timer2_cb, 86400 * 1000, 0)); - ASSERT_OK(uv_run(loop, UV_RUN_DEFAULT)); - - ASSERT_EQ(1, connect_cb_called); - ASSERT_EQ(1, timer1_cb_called); - ASSERT_EQ(2, close_cb_called); - - MAKE_VALGRIND_HAPPY(loop); + ASSERT(r == 0); + ASSERT(0 == uv_timer_init(loop, &timer1_handle)); + ASSERT(0 == uv_timer_start(&timer1_handle, timer1_cb, 1, 0)); + ASSERT(0 == uv_timer_init(loop, &timer2_handle)); + ASSERT(0 == uv_timer_start(&timer2_handle, timer2_cb, 86400 * 1000, 0)); + ASSERT(0 == uv_run(loop, UV_RUN_DEFAULT)); + + ASSERT(connect_cb_called == 1); + ASSERT(timer1_cb_called == 1); + ASSERT(close_cb_called == 2); + + MAKE_VALGRIND_HAPPY(); if (netunreach_errors > 0) RETURN_SKIP("Network unreachable."); diff --git a/test/test-tcp-close.c b/test/test-tcp-close.c index ed19da6..5a7bd68 100644 --- a/test/test-tcp-close.c +++ b/test/test-tcp-close.c @@ -49,7 +49,7 @@ static void connect_cb(uv_connect_t* conn_req, int status) { ASSERT_NOT_NULL(req); r = uv_write(req, (uv_stream_t*)&tcp_handle, &buf, 1, write_cb); - ASSERT_OK(r); + ASSERT(r == 0); } uv_close((uv_handle_t*)&tcp_handle, close_cb); @@ -58,21 +58,21 @@ static void connect_cb(uv_connect_t* conn_req, int status) { static void write_cb(uv_write_t* req, int status) { /* write callbacks should run before the close callback */ - ASSERT_OK(close_cb_called); - ASSERT_PTR_EQ(req->handle, (uv_stream_t*)&tcp_handle); + ASSERT(close_cb_called == 0); + ASSERT(req->handle == (uv_stream_t*)&tcp_handle); write_cb_called++; free(req); } static void close_cb(uv_handle_t* handle) { - ASSERT_PTR_EQ(handle, (uv_handle_t*)&tcp_handle); + ASSERT(handle == (uv_handle_t*)&tcp_handle); close_cb_called++; } static void connection_cb(uv_stream_t* server, int status) { - ASSERT_OK(status); + ASSERT(status == 0); } @@ -80,16 +80,16 @@ static void start_server(uv_loop_t* loop, uv_tcp_t* handle) { struct sockaddr_in addr; int r; - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); + ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); r = uv_tcp_init(loop, handle); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_tcp_bind(handle, (const struct sockaddr*) &addr, 0); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_listen((uv_stream_t*)handle, 128, connection_cb); - ASSERT_OK(r); + ASSERT(r == 0); uv_unref((uv_handle_t*)handle); } @@ -104,7 +104,7 @@ TEST_IMPL(tcp_close) { uv_loop_t* loop; int r; - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); + ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); loop = uv_default_loop(); @@ -112,25 +112,25 @@ TEST_IMPL(tcp_close) { start_server(loop, &tcp_server); r = uv_tcp_init(loop, &tcp_handle); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_tcp_connect(&connect_req, &tcp_handle, (const struct sockaddr*) &addr, connect_cb); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_OK(write_cb_called); - ASSERT_OK(close_cb_called); + ASSERT(write_cb_called == 0); + ASSERT(close_cb_called == 0); r = uv_run(loop, UV_RUN_DEFAULT); - ASSERT_OK(r); + ASSERT(r == 0); printf("%d of %d write reqs seen\n", write_cb_called, NUM_WRITE_REQS); - ASSERT_EQ(write_cb_called, NUM_WRITE_REQS); - ASSERT_EQ(1, close_cb_called); + ASSERT(write_cb_called == NUM_WRITE_REQS); + ASSERT(close_cb_called == 1); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-tcp-connect-error-after-write.c b/test/test-tcp-connect-error-after-write.c index 7321259..3f2e357 100644 --- a/test/test-tcp-connect-error-after-write.c +++ b/test/test-tcp-connect-error-after-write.c @@ -37,14 +37,14 @@ static void close_cb(uv_handle_t* handle) { static void connect_cb(uv_connect_t* req, int status) { - ASSERT_LT(status, 0); + ASSERT(status < 0); connect_cb_called++; uv_close((uv_handle_t*)req->handle, close_cb); } static void write_cb(uv_write_t* req, int status) { - ASSERT_LT(status, 0); + ASSERT(status < 0); write_cb_called++; } @@ -55,11 +55,6 @@ static void write_cb(uv_write_t* req, int status) { * Related issue: https://github.com/joyent/libuv/issues/443 */ TEST_IMPL(tcp_connect_error_after_write) { -#ifdef _WIN32 - RETURN_SKIP("This test is disabled on Windows for now. " - "See https://github.com/joyent/libuv/issues/444\n"); -#else - uv_connect_t connect_req; struct sockaddr_in addr; uv_write_t write_req; @@ -67,32 +62,37 @@ TEST_IMPL(tcp_connect_error_after_write) { uv_buf_t buf; int r; - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); +#ifdef _WIN32 + fprintf(stderr, "This test is disabled on Windows for now.\n"); + fprintf(stderr, "See https://github.com/joyent/libuv/issues/444\n"); + return 0; /* windows slackers... */ +#endif + + ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); buf = uv_buf_init("TEST", 4); r = uv_tcp_init(uv_default_loop(), &conn); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_write(&write_req, (uv_stream_t*)&conn, &buf, 1, write_cb); - ASSERT_EQ(r, UV_EBADF); + ASSERT(r == UV_EBADF); r = uv_tcp_connect(&connect_req, &conn, (const struct sockaddr*) &addr, connect_cb); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_write(&write_req, (uv_stream_t*)&conn, &buf, 1, write_cb); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_EQ(1, connect_cb_called); - ASSERT_EQ(1, write_cb_called); - ASSERT_EQ(1, close_cb_called); + ASSERT(connect_cb_called == 1); + ASSERT(write_cb_called == 1); + ASSERT(close_cb_called == 1); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; -#endif } diff --git a/test/test-tcp-connect-error.c b/test/test-tcp-connect-error.c index ee0f9ee..dda30a5 100644 --- a/test/test-tcp-connect-error.c +++ b/test/test-tcp-connect-error.c @@ -54,20 +54,20 @@ TEST_IMPL(tcp_connect_error_fault) { garbage_addr = (const struct sockaddr_in*) &garbage; r = uv_tcp_init(uv_default_loop(), &server); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_tcp_connect(&req, &server, (const struct sockaddr*) garbage_addr, connect_cb); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); uv_close((uv_handle_t*)&server, close_cb); uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_OK(connect_cb_called); - ASSERT_EQ(1, close_cb_called); + ASSERT(connect_cb_called == 0); + ASSERT(close_cb_called == 1); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-tcp-connect-timeout.c b/test/test-tcp-connect-timeout.c index 4eb834e..0f96815 100644 --- a/test/test-tcp-connect-timeout.c +++ b/test/test-tcp-connect-timeout.c @@ -38,14 +38,14 @@ static void close_cb(uv_handle_t* handle); static void connect_cb(uv_connect_t* req, int status) { - ASSERT_PTR_EQ(req, &connect_req); - ASSERT_EQ(status, UV_ECANCELED); + ASSERT(req == &connect_req); + ASSERT(status == UV_ECANCELED); connect_cb_called++; } static void timer_cb(uv_timer_t* handle) { - ASSERT_PTR_EQ(handle, &timer); + ASSERT(handle == &timer); uv_close((uv_handle_t*)&conn, close_cb); uv_close((uv_handle_t*)&timer, close_cb); } @@ -64,16 +64,16 @@ TEST_IMPL(tcp_connect_timeout) { struct sockaddr_in addr; int r; - ASSERT_OK(uv_ip4_addr("8.8.8.8", 9999, &addr)); + ASSERT(0 == uv_ip4_addr("8.8.8.8", 9999, &addr)); r = uv_timer_init(uv_default_loop(), &timer); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_timer_start(&timer, timer_cb, 50, 0); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_tcp_init(uv_default_loop(), &conn); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_tcp_connect(&connect_req, &conn, @@ -81,12 +81,12 @@ TEST_IMPL(tcp_connect_timeout) { connect_cb); if (r == UV_ENETUNREACH) RETURN_SKIP("Network unreachable."); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_OK(r); + ASSERT(r == 0); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -105,7 +105,7 @@ static int is_supported_system(void) { int min_semver[3] = {10, 0, 16299}; int cnt; uv_utsname_t uname; - ASSERT_OK(uv_os_uname(&uname)); + ASSERT_EQ(uv_os_uname(&uname), 0); if (strcmp(uname.sysname, "Windows_NT") == 0) { cnt = sscanf(uname.release, "%d.%d.%d", &semver[0], &semver[1], &semver[2]); if (cnt != 3) { @@ -130,17 +130,17 @@ TEST_IMPL(tcp_local_connect_timeout) { if (!is_supported_system()) { RETURN_SKIP("Unsupported system"); } - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); + ASSERT_EQ(0, uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); r = uv_timer_init(uv_default_loop(), &timer); - ASSERT_OK(r); + ASSERT_EQ(r, 0); /* Give it 1s to timeout. */ r = uv_timer_start(&timer, timer_cb, 1000, 0); - ASSERT_OK(r); + ASSERT_EQ(r, 0); r = uv_tcp_init(uv_default_loop(), &conn); - ASSERT_OK(r); + ASSERT_EQ(r, 0); r = uv_tcp_connect(&connect_req, &conn, @@ -148,12 +148,12 @@ TEST_IMPL(tcp_local_connect_timeout) { connect_local_cb); if (r == UV_ENETUNREACH) RETURN_SKIP("Network unreachable."); - ASSERT_OK(r); + ASSERT_EQ(r, 0); r = uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_OK(r); + ASSERT(r == 0); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -168,17 +168,17 @@ TEST_IMPL(tcp6_local_connect_timeout) { RETURN_SKIP("IPv6 not supported"); } - ASSERT_OK(uv_ip6_addr("::1", 9999, &addr)); + ASSERT_EQ(0, uv_ip6_addr("::1", 9999, &addr)); r = uv_timer_init(uv_default_loop(), &timer); - ASSERT_OK(r); + ASSERT_EQ(r, 0); /* Give it 1s to timeout. */ r = uv_timer_start(&timer, timer_cb, 1000, 0); - ASSERT_OK(r); + ASSERT_EQ(r, 0); r = uv_tcp_init(uv_default_loop(), &conn); - ASSERT_OK(r); + ASSERT_EQ(r, 0); r = uv_tcp_connect(&connect_req, &conn, @@ -186,11 +186,11 @@ TEST_IMPL(tcp6_local_connect_timeout) { connect_local_cb); if (r == UV_ENETUNREACH) RETURN_SKIP("Network unreachable."); - ASSERT_OK(r); + ASSERT_EQ(r, 0); r = uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_OK(r); + ASSERT_EQ(r, 0); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-tcp-connect6-error.c b/test/test-tcp-connect6-error.c index dc2fce8..2f6e9cb 100644 --- a/test/test-tcp-connect6-error.c +++ b/test/test-tcp-connect6-error.c @@ -23,7 +23,6 @@ #include "task.h" #include #include -#include static int connect_cb_called = 0; @@ -50,80 +49,23 @@ TEST_IMPL(tcp_connect6_error_fault) { int r; uv_connect_t req; - if (!can_ipv6()) - RETURN_SKIP("IPv6 not supported"); - garbage_addr = (const struct sockaddr_in6*) &garbage; r = uv_tcp_init(uv_default_loop(), &server); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_tcp_connect(&req, &server, (const struct sockaddr*) garbage_addr, connect_cb); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); uv_close((uv_handle_t*)&server, close_cb); uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_OK(connect_cb_called); - ASSERT_EQ(1, close_cb_called); - - MAKE_VALGRIND_HAPPY(uv_default_loop()); - return 0; -} - - -TEST_IMPL(tcp_connect6_link_local) { - uv_interface_address_t* ifs; - uv_interface_address_t* p; - struct sockaddr_in6 addr; - uv_connect_t req; - uv_tcp_t server; - int ok; - int n; - - if (!can_ipv6()) - RETURN_SKIP("IPv6 not supported"); - -#if defined(__QEMU__) - /* qemu's sockaddr_in6 translation is broken pre-qemu 8.0.0 - * when host endianness != guest endiannes. - * Fixed in https://github.com/qemu/qemu/commit/44cf6731d6b. - */ - RETURN_SKIP("Test does not currently work in QEMU"); -#endif /* defined(__QEMU__) */ - - /* Check there's an interface that routes link-local (fe80::/10) traffic. */ - ASSERT_OK(uv_interface_addresses(&ifs, &n)); - for (p = ifs; p < &ifs[n]; p++) - if (p->address.address6.sin6_family == AF_INET6) - if (!memcmp(&p->address.address6.sin6_addr, "\xfe\x80", 2)) - break; - ok = (p < &ifs[n]); - uv_free_interface_addresses(ifs, n); - - if (!ok) - RETURN_SKIP("IPv6 link-local traffic not supported"); - - ASSERT_OK(uv_ip6_addr("fe80::0bad:babe", 1337, &addr)); - ASSERT_OK(uv_tcp_init(uv_default_loop(), &server)); - - /* We're making two shaky assumptions here: - * 1. There is a network interface that routes IPv6 link-local traffic, and - * 2. There is no firewall rule that blackholes or otherwise hard-kills the - * connection attempt to the address above, i.e., we don't expect the - * connect() system call to fail synchronously. - */ - ASSERT_OK(uv_tcp_connect(&req, - &server, - (struct sockaddr*) &addr, - connect_cb)); - - uv_close((uv_handle_t*) &server, NULL); - ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT)); + ASSERT(connect_cb_called == 0); + ASSERT(close_cb_called == 1); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-tcp-create-socket-early.c b/test/test-tcp-create-socket-early.c index e8c1aaa..f2bc60d 100644 --- a/test/test-tcp-create-socket-early.c +++ b/test/test-tcp-create-socket-early.c @@ -32,7 +32,7 @@ static void on_connect(uv_connect_t* req, int status) { - ASSERT_OK(status); + ASSERT(status == 0); uv_close((uv_handle_t*) req->handle, NULL); } @@ -41,16 +41,16 @@ static void on_connection(uv_stream_t* server, int status) { uv_tcp_t* handle; int r; - ASSERT_OK(status); + ASSERT(status == 0); handle = malloc(sizeof(*handle)); ASSERT_NOT_NULL(handle); r = uv_tcp_init_ex(server->loop, handle, AF_INET); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_accept(server, (uv_stream_t*)handle); - ASSERT_EQ(r, UV_EBUSY); + ASSERT(r == UV_EBUSY); uv_close((uv_handle_t*) server, NULL); uv_close((uv_handle_t*) handle, (uv_close_cb)free); @@ -61,16 +61,16 @@ static void tcp_listener(uv_loop_t* loop, uv_tcp_t* server) { struct sockaddr_in addr; int r; - ASSERT_OK(uv_ip4_addr("0.0.0.0", TEST_PORT, &addr)); + ASSERT(0 == uv_ip4_addr("0.0.0.0", TEST_PORT, &addr)); r = uv_tcp_init(loop, server); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_tcp_bind(server, (const struct sockaddr*) &addr, 0); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_listen((uv_stream_t*) server, 128, on_connection); - ASSERT_OK(r); + ASSERT(r == 0); } @@ -78,16 +78,16 @@ static void tcp_connector(uv_loop_t* loop, uv_tcp_t* client, uv_connect_t* req) struct sockaddr_in server_addr; int r; - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &server_addr)); + ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &server_addr)); r = uv_tcp_init(loop, client); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_tcp_connect(req, client, (const struct sockaddr*) &server_addr, on_connect); - ASSERT_OK(r); + ASSERT(r == 0); } @@ -98,39 +98,37 @@ TEST_IMPL(tcp_create_early) { uv_os_fd_t fd; int r, namelen; - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); + ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); r = uv_tcp_init_ex(uv_default_loop(), &client, AF_INET); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_fileno((const uv_handle_t*) &client, &fd); - ASSERT_OK(r); + ASSERT(r == 0); + ASSERT(fd != INVALID_FD); /* Windows returns WSAEINVAL if the socket is not bound */ #ifndef _WIN32 - ASSERT_NE(fd, INVALID_FD); namelen = sizeof sockname; r = uv_tcp_getsockname(&client, (struct sockaddr*) &sockname, &namelen); - ASSERT_OK(r); - ASSERT_EQ(sockname.sin_family, AF_INET); -#else - ASSERT_PTR_NE(fd, INVALID_FD); + ASSERT(r == 0); + ASSERT(sockname.sin_family == AF_INET); #endif r = uv_tcp_bind(&client, (const struct sockaddr*) &addr, 0); - ASSERT_OK(r); + ASSERT(r == 0); namelen = sizeof sockname; r = uv_tcp_getsockname(&client, (struct sockaddr*) &sockname, &namelen); - ASSERT_OK(r); - ASSERT_OK(memcmp(&addr.sin_addr, - &sockname.sin_addr, - sizeof(addr.sin_addr))); + ASSERT(r == 0); + ASSERT(memcmp(&addr.sin_addr, + &sockname.sin_addr, + sizeof(addr.sin_addr)) == 0); uv_close((uv_handle_t*) &client, NULL); uv_run(uv_default_loop(), UV_RUN_DEFAULT); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -144,40 +142,38 @@ TEST_IMPL(tcp_create_early_bad_bind) { if (!can_ipv6()) RETURN_SKIP("IPv6 not supported"); - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); + ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); r = uv_tcp_init_ex(uv_default_loop(), &client, AF_INET6); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_fileno((const uv_handle_t*) &client, &fd); - ASSERT_OK(r); + ASSERT(r == 0); + ASSERT(fd != INVALID_FD); /* Windows returns WSAEINVAL if the socket is not bound */ #ifndef _WIN32 - ASSERT_NE(fd, INVALID_FD); { int namelen; struct sockaddr_in6 sockname; namelen = sizeof sockname; r = uv_tcp_getsockname(&client, (struct sockaddr*) &sockname, &namelen); - ASSERT_OK(r); - ASSERT_EQ(sockname.sin6_family, AF_INET6); + ASSERT(r == 0); + ASSERT(sockname.sin6_family == AF_INET6); } -#else - ASSERT_PTR_NE(fd, INVALID_FD); #endif r = uv_tcp_bind(&client, (const struct sockaddr*) &addr, 0); #if !defined(_WIN32) && !defined(__CYGWIN__) && !defined(__MSYS__) - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); #else - ASSERT_EQ(r, UV_EFAULT); + ASSERT(r == UV_EFAULT); #endif uv_close((uv_handle_t*) &client, NULL); uv_run(uv_default_loop(), UV_RUN_DEFAULT); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -187,14 +183,14 @@ TEST_IMPL(tcp_create_early_bad_domain) { int r; r = uv_tcp_init_ex(uv_default_loop(), &client, 47); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); r = uv_tcp_init_ex(uv_default_loop(), &client, 1024); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); uv_run(uv_default_loop(), UV_RUN_DEFAULT); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -208,6 +204,6 @@ TEST_IMPL(tcp_create_early_accept) { uv_run(uv_default_loop(), UV_RUN_DEFAULT); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-tcp-flags.c b/test/test-tcp-flags.c index 30178d7..68afb39 100644 --- a/test/test-tcp-flags.c +++ b/test/test-tcp-flags.c @@ -34,19 +34,19 @@ TEST_IMPL(tcp_flags) { loop = uv_default_loop(); r = uv_tcp_init(loop, &handle); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_tcp_nodelay(&handle, 1); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_tcp_keepalive(&handle, 1, 60); - ASSERT_OK(r); + ASSERT(r == 0); uv_close((uv_handle_t*)&handle, NULL); r = uv_run(loop, UV_RUN_DEFAULT); - ASSERT_OK(r); + ASSERT(r == 0); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-tcp-oob.c b/test/test-tcp-oob.c index 7962fa9..53f8231 100644 --- a/test/test-tcp-oob.c +++ b/test/test-tcp-oob.c @@ -61,22 +61,22 @@ static void read_cb(uv_stream_t* handle, ssize_t nread, const uv_buf_t* buf) { #endif uv_os_fd_t fd; - ASSERT_GE(nread, 0); - ASSERT_OK(uv_fileno((uv_handle_t*)handle, &fd)); - ASSERT_OK(uv_idle_start(&idle, idle_cb)); + ASSERT(nread >= 0); + ASSERT(0 == uv_fileno((uv_handle_t*)handle, &fd)); + ASSERT(0 == uv_idle_start(&idle, idle_cb)); #ifdef __MVS__ /* Need to flush out the OOB data. Otherwise, this callback will get * triggered on every poll with nread = 0. */ - ASSERT_NE(-1, recv(fd, lbuf, sizeof(lbuf), MSG_OOB)); + ASSERT(-1 != recv(fd, lbuf, sizeof(lbuf), MSG_OOB)); #endif } static void connect_cb(uv_connect_t* req, int status) { - ASSERT_PTR_EQ(req->handle, (uv_stream_t*) &client_handle); - ASSERT_OK(status); + ASSERT(req->handle == (uv_stream_t*) &client_handle); + ASSERT(0 == status); } @@ -84,14 +84,14 @@ static void connection_cb(uv_stream_t* handle, int status) { int r; uv_os_fd_t fd; - ASSERT_OK(status); - ASSERT_OK(uv_accept(handle, (uv_stream_t*) &peer_handle)); - ASSERT_OK(uv_read_start((uv_stream_t*) &peer_handle, alloc_cb, read_cb)); + ASSERT(0 == status); + ASSERT(0 == uv_accept(handle, (uv_stream_t*) &peer_handle)); + ASSERT(0 == uv_read_start((uv_stream_t*) &peer_handle, alloc_cb, read_cb)); /* Send some OOB data */ - ASSERT_OK(uv_fileno((uv_handle_t*) &client_handle, &fd)); + ASSERT(0 == uv_fileno((uv_handle_t*) &client_handle, &fd)); - ASSERT_OK(uv_stream_set_blocking((uv_stream_t*) &client_handle, 1)); + ASSERT(0 == uv_stream_set_blocking((uv_stream_t*) &client_handle, 1)); /* The problem triggers only on a second message, it seem that xnu is not * triggering `kevent()` for the first one @@ -99,14 +99,14 @@ static void connection_cb(uv_stream_t* handle, int status) { do { r = send(fd, "hello", 5, MSG_OOB); } while (r < 0 && errno == EINTR); - ASSERT_EQ(5, r); + ASSERT(5 == r); do { r = send(fd, "hello", 5, MSG_OOB); } while (r < 0 && errno == EINTR); - ASSERT_EQ(5, r); + ASSERT(5 == r); - ASSERT_OK(uv_stream_set_blocking((uv_stream_t*) &client_handle, 0)); + ASSERT(0 == uv_stream_set_blocking((uv_stream_t*) &client_handle, 0)); } @@ -114,28 +114,28 @@ TEST_IMPL(tcp_oob) { struct sockaddr_in addr; uv_loop_t* loop; - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); + ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); loop = uv_default_loop(); - ASSERT_OK(uv_tcp_init(loop, &server_handle)); - ASSERT_OK(uv_tcp_init(loop, &client_handle)); - ASSERT_OK(uv_tcp_init(loop, &peer_handle)); - ASSERT_OK(uv_idle_init(loop, &idle)); - ASSERT_OK(uv_tcp_bind(&server_handle, (const struct sockaddr*) &addr, 0)); - ASSERT_OK(uv_listen((uv_stream_t*) &server_handle, 1, connection_cb)); + ASSERT(0 == uv_tcp_init(loop, &server_handle)); + ASSERT(0 == uv_tcp_init(loop, &client_handle)); + ASSERT(0 == uv_tcp_init(loop, &peer_handle)); + ASSERT(0 == uv_idle_init(loop, &idle)); + ASSERT(0 == uv_tcp_bind(&server_handle, (const struct sockaddr*) &addr, 0)); + ASSERT(0 == uv_listen((uv_stream_t*) &server_handle, 1, connection_cb)); /* Ensure two separate packets */ - ASSERT_OK(uv_tcp_nodelay(&client_handle, 1)); + ASSERT(0 == uv_tcp_nodelay(&client_handle, 1)); - ASSERT_OK(uv_tcp_connect(&connect_req, - &client_handle, - (const struct sockaddr*) &addr, - connect_cb)); - ASSERT_OK(uv_run(loop, UV_RUN_DEFAULT)); + ASSERT(0 == uv_tcp_connect(&connect_req, + &client_handle, + (const struct sockaddr*) &addr, + connect_cb)); + ASSERT(0 == uv_run(loop, UV_RUN_DEFAULT)); - ASSERT_EQ(ticks, kMaxTicks); + ASSERT(ticks == kMaxTicks); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-tcp-open.c b/test/test-tcp-open.c index 3fbcf2a..7e49139 100644 --- a/test/test-tcp-open.c +++ b/test/test-tcp-open.c @@ -46,7 +46,7 @@ static void startup(void) { #ifdef _WIN32 struct WSAData wsa_data; int r = WSAStartup(MAKEWORD(2, 2), &wsa_data); - ASSERT_OK(r); + ASSERT(r == 0); #endif } @@ -56,9 +56,9 @@ static uv_os_sock_t create_tcp_socket(void) { sock = socket(AF_INET, SOCK_STREAM, IPPROTO_IP); #ifdef _WIN32 - ASSERT_NE(sock, INVALID_SOCKET); + ASSERT(sock != INVALID_SOCKET); #else - ASSERT_GE(sock, 0); + ASSERT(sock >= 0); #endif #ifndef _WIN32 @@ -66,7 +66,7 @@ static uv_os_sock_t create_tcp_socket(void) { /* Allow reuse of the port. */ int yes = 1; int r = setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof yes); - ASSERT_OK(r); + ASSERT(r == 0); } #endif @@ -81,7 +81,7 @@ static void close_socket(uv_os_sock_t sock) { #else r = close(sock); #endif - ASSERT_OK(r); + ASSERT(r == 0); } @@ -89,7 +89,7 @@ static void alloc_cb(uv_handle_t* handle, size_t suggested_size, uv_buf_t* buf) { static char slab[65536]; - ASSERT_LE(suggested_size, sizeof(slab)); + ASSERT(suggested_size <= sizeof(slab)); buf->base = slab; buf->len = sizeof(slab); } @@ -102,8 +102,8 @@ static void close_cb(uv_handle_t* handle) { static void shutdown_cb(uv_shutdown_t* req, int status) { - ASSERT_PTR_EQ(req, &shutdown_req); - ASSERT_OK(status); + ASSERT(req == &shutdown_req); + ASSERT(status == 0); /* Now we wait for the EOF */ shutdown_cb_called++; @@ -114,11 +114,11 @@ static void read_cb(uv_stream_t* tcp, ssize_t nread, const uv_buf_t* buf) { ASSERT_NOT_NULL(tcp); if (nread >= 0) { - ASSERT_EQ(4, nread); - ASSERT_OK(memcmp("PING", buf->base, nread)); + ASSERT(nread == 4); + ASSERT(memcmp("PING", buf->base, nread) == 0); } else { - ASSERT_EQ(nread, UV_EOF); + ASSERT(nread == UV_EOF); uv_close((uv_handle_t*)tcp, close_cb); } } @@ -130,9 +130,9 @@ static void read1_cb(uv_stream_t* tcp, ssize_t nread, const uv_buf_t* buf) { if (nread >= 0) { for (i = 0; i < nread; ++i) - ASSERT_EQ(buf->base[i], 'P'); + ASSERT(buf->base[i] == 'P'); } else { - ASSERT_EQ(nread, UV_EOF); + ASSERT(nread == UV_EOF); printf("GOT EOF\n"); uv_close((uv_handle_t*)tcp, close_cb); } @@ -166,7 +166,7 @@ static void write1_cb(uv_write_t* req, int status) { buf = uv_buf_init("P", 1); r = uv_write(&write_req, req->handle, &buf, 1, write1_cb); - ASSERT_OK(r); + ASSERT(r == 0); write_cb_called++; } @@ -177,7 +177,7 @@ static void timer_cb(uv_timer_t* handle) { /* Shutdown on drain. */ r = uv_shutdown(&shutdown_req, (uv_stream_t*) &client, shutdown_cb); - ASSERT_OK(r); + ASSERT(r == 0); shutdown_requested++; } @@ -187,22 +187,22 @@ static void connect_cb(uv_connect_t* req, int status) { uv_stream_t* stream; int r; - ASSERT_PTR_EQ(req, &connect_req); - ASSERT_OK(status); + ASSERT(req == &connect_req); + ASSERT(status == 0); stream = req->handle; connect_cb_called++; r = uv_write(&write_req, stream, &buf, 1, write_cb); - ASSERT_OK(r); + ASSERT(r == 0); /* Shutdown on drain. */ r = uv_shutdown(&shutdown_req, stream, shutdown_cb); - ASSERT_OK(r); + ASSERT(r == 0); /* Start reading */ r = uv_read_start(stream, alloc_cb, read_cb); - ASSERT_OK(r); + ASSERT(r == 0); } @@ -211,25 +211,25 @@ static void connect1_cb(uv_connect_t* req, int status) { uv_stream_t* stream; int r; - ASSERT_PTR_EQ(req, &connect_req); - ASSERT_OK(status); + ASSERT(req == &connect_req); + ASSERT(status == 0); stream = req->handle; connect_cb_called++; r = uv_timer_init(uv_default_loop(), &tm); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_timer_start(&tm, timer_cb, 2000, 0); - ASSERT_OK(r); + ASSERT(r == 0); buf = uv_buf_init("P", 1); r = uv_write(&write_req, stream, &buf, 1, write1_cb); - ASSERT_OK(r); + ASSERT(r == 0); /* Start reading */ r = uv_read_start(stream, alloc_cb, read1_cb); - ASSERT_OK(r); + ASSERT(r == 0); } @@ -239,30 +239,30 @@ TEST_IMPL(tcp_open) { int r; uv_tcp_t client2; - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); + ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); startup(); sock = create_tcp_socket(); r = uv_tcp_init(uv_default_loop(), &client); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_tcp_open(&client, sock); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_tcp_connect(&connect_req, &client, (const struct sockaddr*) &addr, connect_cb); - ASSERT_OK(r); + ASSERT(r == 0); #ifndef _WIN32 { r = uv_tcp_init(uv_default_loop(), &client2); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_tcp_open(&client2, sock); - ASSERT_EQ(r, UV_EEXIST); + ASSERT(r == UV_EEXIST); uv_close((uv_handle_t*) &client2, NULL); } @@ -272,12 +272,12 @@ TEST_IMPL(tcp_open) { uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_EQ(1, shutdown_cb_called); - ASSERT_EQ(1, connect_cb_called); - ASSERT_EQ(1, write_cb_called); - ASSERT_EQ(1, close_cb_called); + ASSERT(shutdown_cb_called == 1); + ASSERT(connect_cb_called == 1); + ASSERT(write_cb_called == 1); + ASSERT(close_cb_called == 1); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -292,19 +292,19 @@ TEST_IMPL(tcp_open_twice) { sock2 = create_tcp_socket(); r = uv_tcp_init(uv_default_loop(), &client); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_tcp_open(&client, sock1); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_tcp_open(&client, sock2); - ASSERT_EQ(r, UV_EBUSY); + ASSERT(r == UV_EBUSY); close_socket(sock2); uv_close((uv_handle_t*) &client, NULL); uv_run(uv_default_loop(), UV_RUN_DEFAULT); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -317,17 +317,17 @@ TEST_IMPL(tcp_open_bound) { startup(); sock = create_tcp_socket(); - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); + ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); - ASSERT_OK(uv_tcp_init(uv_default_loop(), &server)); + ASSERT(0 == uv_tcp_init(uv_default_loop(), &server)); - ASSERT_OK(bind(sock, (struct sockaddr*) &addr, sizeof(addr))); + ASSERT(0 == bind(sock, (struct sockaddr*) &addr, sizeof(addr))); - ASSERT_OK(uv_tcp_open(&server, sock)); + ASSERT(0 == uv_tcp_open(&server, sock)); - ASSERT_OK(uv_listen((uv_stream_t*) &server, 128, NULL)); + ASSERT(0 == uv_listen((uv_stream_t*) &server, 128, NULL)); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -338,36 +338,30 @@ TEST_IMPL(tcp_open_connected) { uv_os_sock_t sock; uv_buf_t buf = uv_buf_init("PING", 4); - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); + ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); startup(); sock = create_tcp_socket(); - ASSERT_OK(connect(sock, (struct sockaddr*) &addr, sizeof(addr))); + ASSERT(0 == connect(sock, (struct sockaddr*) &addr, sizeof(addr))); - ASSERT_OK(uv_tcp_init(uv_default_loop(), &client)); + ASSERT(0 == uv_tcp_init(uv_default_loop(), &client)); - ASSERT_OK(uv_tcp_open(&client, sock)); + ASSERT(0 == uv_tcp_open(&client, sock)); - ASSERT_OK(uv_write(&write_req, - (uv_stream_t*) &client, - &buf, - 1, - write_cb)); + ASSERT(0 == uv_write(&write_req, (uv_stream_t*) &client, &buf, 1, write_cb)); - ASSERT_OK(uv_shutdown(&shutdown_req, - (uv_stream_t*) &client, - shutdown_cb)); + ASSERT(0 == uv_shutdown(&shutdown_req, (uv_stream_t*) &client, shutdown_cb)); - ASSERT_OK(uv_read_start((uv_stream_t*) &client, alloc_cb, read_cb)); + ASSERT(0 == uv_read_start((uv_stream_t*) &client, alloc_cb, read_cb)); uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_EQ(1, shutdown_cb_called); - ASSERT_EQ(1, write_cb_called); - ASSERT_EQ(1, close_cb_called); + ASSERT(shutdown_cb_called == 1); + ASSERT(write_cb_called == 1); + ASSERT(close_cb_called == 1); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -377,31 +371,31 @@ TEST_IMPL(tcp_write_ready) { uv_os_sock_t sock; int r; - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); + ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); startup(); sock = create_tcp_socket(); r = uv_tcp_init(uv_default_loop(), &client); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_tcp_open(&client, sock); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_tcp_connect(&connect_req, &client, (const struct sockaddr*) &addr, connect1_cb); - ASSERT_OK(r); + ASSERT(r == 0); uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_EQ(1, shutdown_cb_called); - ASSERT_EQ(1, shutdown_requested); - ASSERT_EQ(1, connect_cb_called); - ASSERT_GT(write_cb_called, 0); - ASSERT_EQ(1, close_cb_called); + ASSERT(shutdown_cb_called == 1); + ASSERT(shutdown_requested == 1); + ASSERT(connect_cb_called == 1); + ASSERT(write_cb_called > 0); + ASSERT(close_cb_called == 1); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-tcp-read-stop-start.c b/test/test-tcp-read-stop-start.c index 68d6f7c..9bccbc1 100644 --- a/test/test-tcp-read-stop-start.c +++ b/test/test-tcp-read-stop-start.c @@ -33,14 +33,14 @@ static uv_connect_t connect_req; static void on_read2(uv_stream_t* stream, ssize_t nread, const uv_buf_t* buf); static void on_write_close_immediately(uv_write_t* req, int status) { - ASSERT_OK(status); + ASSERT(0 == status); uv_close((uv_handle_t*)req->handle, NULL); /* Close immediately */ free(req); } static void on_write(uv_write_t* req, int status) { - ASSERT_OK(status); + ASSERT(0 == status); free(req); } @@ -50,7 +50,7 @@ static void do_write(uv_stream_t* stream, uv_write_cb cb) { uv_buf_t buf; buf.base = "1234578"; buf.len = 8; - ASSERT_OK(uv_write(req, stream, &buf, 1, cb)); + ASSERT(0 == uv_write(req, stream, &buf, 1, cb)); } static void on_alloc(uv_handle_t* handle, @@ -62,22 +62,22 @@ static void on_alloc(uv_handle_t* handle, } static void on_read1(uv_stream_t* stream, ssize_t nread, const uv_buf_t* buf) { - ASSERT_GE(nread, 0); + ASSERT(nread >= 0); /* Do write on a half open connection to force WSAECONNABORTED (on Windows) * in the subsequent uv_read_start() */ do_write(stream, on_write); - ASSERT_OK(uv_read_stop(stream)); + ASSERT(0 == uv_read_stop(stream)); - ASSERT_OK(uv_read_start(stream, on_alloc, on_read2)); + ASSERT(0 == uv_read_start(stream, on_alloc, on_read2)); read_cb_called++; } static void on_read2(uv_stream_t* stream, ssize_t nread, const uv_buf_t* buf) { - ASSERT_LT(nread, 0); + ASSERT(nread < 0); uv_close((uv_handle_t*)stream, NULL); uv_close((uv_handle_t*)&server, NULL); @@ -86,17 +86,17 @@ static void on_read2(uv_stream_t* stream, ssize_t nread, const uv_buf_t* buf) { } static void on_connection(uv_stream_t* server, int status) { - ASSERT_OK(status); + ASSERT(0 == status); - ASSERT_OK(uv_tcp_init(server->loop, &connection)); + ASSERT(0 == uv_tcp_init(server->loop, &connection)); - ASSERT_OK(uv_accept(server, (uv_stream_t* )&connection)); + ASSERT(0 == uv_accept(server, (uv_stream_t* )&connection)); - ASSERT_OK(uv_read_start((uv_stream_t*)&connection, on_alloc, on_read1)); + ASSERT(0 == uv_read_start((uv_stream_t*)&connection, on_alloc, on_read1)); } static void on_connect(uv_connect_t* req, int status) { - ASSERT_OK(status); + ASSERT(0 == status); do_write((uv_stream_t*)&client, on_write_close_immediately); } @@ -107,30 +107,30 @@ TEST_IMPL(tcp_read_stop_start) { { /* Server */ struct sockaddr_in addr; - ASSERT_OK(uv_ip4_addr("0.0.0.0", TEST_PORT, &addr)); + ASSERT(0 == uv_ip4_addr("0.0.0.0", TEST_PORT, &addr)); - ASSERT_OK(uv_tcp_init(loop, &server)); + ASSERT(0 == uv_tcp_init(loop, &server)); - ASSERT_OK(uv_tcp_bind(&server, (struct sockaddr*) & addr, 0)); + ASSERT(0 == uv_tcp_bind(&server, (struct sockaddr*) & addr, 0)); - ASSERT_OK(uv_listen((uv_stream_t*)&server, 10, on_connection)); + ASSERT(0 == uv_listen((uv_stream_t*)&server, 10, on_connection)); } { /* Client */ struct sockaddr_in addr; - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); + ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); - ASSERT_OK(uv_tcp_init(loop, &client)); + ASSERT(0 == uv_tcp_init(loop, &client)); - ASSERT_OK(uv_tcp_connect(&connect_req, &client, - (const struct sockaddr*) & addr, on_connect)); + ASSERT(0 == uv_tcp_connect(&connect_req, &client, + (const struct sockaddr*) & addr, on_connect)); } - ASSERT_OK(uv_run(loop, UV_RUN_DEFAULT)); + ASSERT(0 == uv_run(loop, UV_RUN_DEFAULT)); - ASSERT_GE(read_cb_called, 2); + ASSERT(read_cb_called >= 2); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-tcp-read-stop.c b/test/test-tcp-read-stop.c index 114c5ec..488e8fb 100644 --- a/test/test-tcp-read-stop.c +++ b/test/test-tcp-read-stop.c @@ -40,21 +40,21 @@ static void write_cb(uv_write_t* req, int status) { static void timer_cb(uv_timer_t* handle) { uv_buf_t buf = uv_buf_init("PING", 4); - ASSERT_OK(uv_write(&write_req, - (uv_stream_t*) &tcp_handle, - &buf, - 1, - write_cb)); - ASSERT_OK(uv_read_stop((uv_stream_t*) &tcp_handle)); + ASSERT(0 == uv_write(&write_req, + (uv_stream_t*) &tcp_handle, + &buf, + 1, + write_cb)); + ASSERT(0 == uv_read_stop((uv_stream_t*) &tcp_handle)); } static void connect_cb(uv_connect_t* req, int status) { - ASSERT_OK(status); - ASSERT_OK(uv_timer_start(&timer_handle, timer_cb, 50, 0)); - ASSERT_OK(uv_read_start((uv_stream_t*) &tcp_handle, - (uv_alloc_cb) fail_cb, - (uv_read_cb) fail_cb)); + ASSERT(0 == status); + ASSERT(0 == uv_timer_start(&timer_handle, timer_cb, 50, 0)); + ASSERT(0 == uv_read_start((uv_stream_t*) &tcp_handle, + (uv_alloc_cb) fail_cb, + (uv_read_cb) fail_cb)); } @@ -62,15 +62,15 @@ TEST_IMPL(tcp_read_stop) { uv_connect_t connect_req; struct sockaddr_in addr; - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); - ASSERT_OK(uv_timer_init(uv_default_loop(), &timer_handle)); - ASSERT_OK(uv_tcp_init(uv_default_loop(), &tcp_handle)); - ASSERT_OK(uv_tcp_connect(&connect_req, - &tcp_handle, - (const struct sockaddr*) &addr, - connect_cb)); - ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT)); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); + ASSERT(0 == uv_timer_init(uv_default_loop(), &timer_handle)); + ASSERT(0 == uv_tcp_init(uv_default_loop(), &tcp_handle)); + ASSERT(0 == uv_tcp_connect(&connect_req, + &tcp_handle, + (const struct sockaddr*) &addr, + connect_cb)); + ASSERT(0 == uv_run(uv_default_loop(), UV_RUN_DEFAULT)); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-tcp-rst.c b/test/test-tcp-rst.c index 7729f03..ed48e74 100644 --- a/test/test-tcp-rst.c +++ b/test/test-tcp-rst.c @@ -31,7 +31,7 @@ static int called_close_cb; static void close_cb(uv_handle_t* handle) { - ASSERT_PTR_EQ(handle, (uv_handle_t*) &tcp); + ASSERT(handle == (uv_handle_t*) &tcp); called_close_cb++; } @@ -48,7 +48,7 @@ static void read_cb(uv_stream_t* t, ssize_t nread, const uv_buf_t* buf) { ASSERT_EQ(nread, UV_ECONNRESET); int fd; - ASSERT_OK(uv_fileno((uv_handle_t*) t, &fd)); + ASSERT_EQ(0, uv_fileno((uv_handle_t*) t, &fd)); uv_handle_type type = uv_guess_handle(fd); ASSERT_EQ(type, UV_TCP); @@ -58,11 +58,11 @@ static void read_cb(uv_stream_t* t, ssize_t nread, const uv_buf_t* buf) { static void connect_cb(uv_connect_t *req, int status) { - ASSERT_OK(status); + ASSERT_EQ(status, 0); ASSERT_PTR_EQ(req, &connect_req); /* Start reading from the connection so we receive the RST in uv__read. */ - ASSERT_OK(uv_read_start((uv_stream_t*) &tcp, alloc_cb, read_cb)); + ASSERT_EQ(0, uv_read_start((uv_stream_t*) &tcp, alloc_cb, read_cb)); /* Write 'QSH' to receive RST from the echo server. */ ASSERT_EQ(qbuf.len, uv_try_write((uv_stream_t*) &tcp, &qbuf, 1)); @@ -76,9 +76,6 @@ static void connect_cb(uv_connect_t *req, int status) { * RST. Test checks that uv_guess_handle still works on a reset TCP handle. */ TEST_IMPL(tcp_rst) { -#if defined(__OpenBSD__) - RETURN_SKIP("Test does not currently work in OpenBSD"); -#endif #ifndef _WIN32 struct sockaddr_in server_addr; int r; @@ -86,23 +83,23 @@ TEST_IMPL(tcp_rst) { qbuf.base = "QSH"; qbuf.len = 3; - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &server_addr)); + ASSERT_EQ(0, uv_ip4_addr("127.0.0.1", TEST_PORT, &server_addr)); r = uv_tcp_init(uv_default_loop(), &tcp); - ASSERT_OK(r); + ASSERT_EQ(r, 0); r = uv_tcp_connect(&connect_req, &tcp, (const struct sockaddr*) &server_addr, connect_cb); - ASSERT_OK(r); + ASSERT_EQ(r, 0); uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_EQ(1, called_alloc_cb); - ASSERT_EQ(1, called_connect_cb); - ASSERT_EQ(1, called_close_cb); + ASSERT_EQ(called_alloc_cb, 1); + ASSERT_EQ(called_connect_cb, 1); + ASSERT_EQ(called_close_cb, 1); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; #else RETURN_SKIP("Unix only test"); diff --git a/test/test-tcp-shutdown-after-write.c b/test/test-tcp-shutdown-after-write.c index cd8c24d..463b4b0 100644 --- a/test/test-tcp-shutdown-after-write.c +++ b/test/test-tcp-shutdown-after-write.c @@ -66,10 +66,10 @@ static void timer_cb(uv_timer_t* handle) { buf = uv_buf_init("TEST", 4); r = uv_write(&write_req, (uv_stream_t*)&conn, &buf, 1, write_cb); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_shutdown(&shutdown_req, (uv_stream_t*)&conn, shutdown_cb); - ASSERT_OK(r); + ASSERT(r == 0); } @@ -80,22 +80,22 @@ static void read_cb(uv_stream_t* handle, ssize_t nread, const uv_buf_t* buf) { static void connect_cb(uv_connect_t* req, int status) { int r; - ASSERT_OK(status); + ASSERT(status == 0); connect_cb_called++; r = uv_read_start((uv_stream_t*)&conn, alloc_cb, read_cb); - ASSERT_OK(r); + ASSERT(r == 0); } static void write_cb(uv_write_t* req, int status) { - ASSERT_OK(status); + ASSERT(status == 0); write_cb_called++; } static void shutdown_cb(uv_shutdown_t* req, int status) { - ASSERT_OK(status); + ASSERT(status == 0); shutdown_cb_called++; uv_close((uv_handle_t*)&conn, close_cb); } @@ -106,33 +106,33 @@ TEST_IMPL(tcp_shutdown_after_write) { uv_loop_t* loop; int r; - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); + ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); loop = uv_default_loop(); r = uv_timer_init(loop, &timer); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_timer_start(&timer, timer_cb, 125, 0); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_tcp_init(loop, &conn); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_tcp_connect(&connect_req, &conn, (const struct sockaddr*) &addr, connect_cb); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_run(loop, UV_RUN_DEFAULT); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_EQ(1, connect_cb_called); - ASSERT_EQ(1, write_cb_called); - ASSERT_EQ(1, shutdown_cb_called); - ASSERT_EQ(1, conn_close_cb_called); - ASSERT_EQ(1, timer_close_cb_called); + ASSERT(connect_cb_called == 1); + ASSERT(write_cb_called == 1); + ASSERT(shutdown_cb_called == 1); + ASSERT(conn_close_cb_called == 1); + ASSERT(timer_close_cb_called == 1); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-tcp-try-write-error.c b/test/test-tcp-try-write-error.c index 80a23ed..2201d0e 100644 --- a/test/test-tcp-try-write-error.c +++ b/test/test-tcp-try-write-error.c @@ -49,21 +49,21 @@ static void incoming_close_cb(uv_handle_t* handle) { r = uv_try_write((uv_stream_t*) &client, &buf, 1); fprintf(stderr, "uv_try_write error: %d %s\n", r, uv_strerror(r)); ASSERT(r == UV_EPIPE || r == UV_ECONNABORTED || r == UV_ECONNRESET); - ASSERT_OK(client.write_queue_size); + ASSERT(client.write_queue_size == 0); } static void connect_cb(uv_connect_t* req, int status) { - ASSERT_OK(status); + ASSERT(status == 0); connect_cb_called++; } static void connection_cb(uv_stream_t* tcp, int status) { - ASSERT_OK(status); + ASSERT(status == 0); - ASSERT_OK(uv_tcp_init(tcp->loop, &incoming)); - ASSERT_OK(uv_accept(tcp, (uv_stream_t*) &incoming)); + ASSERT(0 == uv_tcp_init(tcp->loop, &incoming)); + ASSERT(0 == uv_accept(tcp, (uv_stream_t*) &incoming)); connection_cb_called++; uv_close((uv_handle_t*) &incoming, incoming_close_cb); @@ -74,11 +74,11 @@ static void connection_cb(uv_stream_t* tcp, int status) { static void start_server(void) { struct sockaddr_in addr; - ASSERT_OK(uv_ip4_addr("0.0.0.0", TEST_PORT, &addr)); + ASSERT(0 == uv_ip4_addr("0.0.0.0", TEST_PORT, &addr)); - ASSERT_OK(uv_tcp_init(uv_default_loop(), &server)); - ASSERT_OK(uv_tcp_bind(&server, (struct sockaddr*) &addr, 0)); - ASSERT_OK(uv_listen((uv_stream_t*) &server, 128, connection_cb)); + ASSERT(0 == uv_tcp_init(uv_default_loop(), &server)); + ASSERT(0 == uv_tcp_bind(&server, (struct sockaddr*) &addr, 0)); + ASSERT(0 == uv_listen((uv_stream_t*) &server, 128, connection_cb)); } @@ -88,22 +88,22 @@ TEST_IMPL(tcp_try_write_error) { start_server(); - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); + ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); - ASSERT_OK(uv_tcp_init(uv_default_loop(), &client)); - ASSERT_OK(uv_tcp_connect(&connect_req, - &client, - (struct sockaddr*) &addr, - connect_cb)); + ASSERT(0 == uv_tcp_init(uv_default_loop(), &client)); + ASSERT(0 == uv_tcp_connect(&connect_req, + &client, + (struct sockaddr*) &addr, + connect_cb)); - ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT)); + ASSERT(0 == uv_run(uv_default_loop(), UV_RUN_DEFAULT)); uv_close((uv_handle_t*) &client, close_cb); - ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT)); + ASSERT(0 == uv_run(uv_default_loop(), UV_RUN_DEFAULT)); - ASSERT_EQ(1, connect_cb_called); - ASSERT_EQ(3, close_cb_called); - ASSERT_EQ(1, connection_cb_called); + ASSERT(connect_cb_called == 1); + ASSERT(close_cb_called == 3); + ASSERT(connection_cb_called == 1); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-tcp-try-write.c b/test/test-tcp-try-write.c index afb20ec..97a1d6e 100644 --- a/test/test-tcp-try-write.c +++ b/test/test-tcp-try-write.c @@ -46,7 +46,7 @@ static void close_cb(uv_handle_t* handle) { static void connect_cb(uv_connect_t* req, int status) { int r; uv_buf_t buf; - ASSERT_OK(status); + ASSERT(status == 0); connect_cb_called++; do { @@ -87,24 +87,24 @@ static void read_cb(uv_stream_t* tcp, ssize_t nread, const uv_buf_t* buf) { static void connection_cb(uv_stream_t* tcp, int status) { - ASSERT_OK(status); + ASSERT(status == 0); - ASSERT_OK(uv_tcp_init(tcp->loop, &incoming)); - ASSERT_OK(uv_accept(tcp, (uv_stream_t*) &incoming)); + ASSERT(0 == uv_tcp_init(tcp->loop, &incoming)); + ASSERT(0 == uv_accept(tcp, (uv_stream_t*) &incoming)); connection_cb_called++; - ASSERT_OK(uv_read_start((uv_stream_t*) &incoming, alloc_cb, read_cb)); + ASSERT(0 == uv_read_start((uv_stream_t*) &incoming, alloc_cb, read_cb)); } static void start_server(void) { struct sockaddr_in addr; - ASSERT_OK(uv_ip4_addr("0.0.0.0", TEST_PORT, &addr)); + ASSERT(0 == uv_ip4_addr("0.0.0.0", TEST_PORT, &addr)); - ASSERT_OK(uv_tcp_init(uv_default_loop(), &server)); - ASSERT_OK(uv_tcp_bind(&server, (struct sockaddr*) &addr, 0)); - ASSERT_OK(uv_listen((uv_stream_t*) &server, 128, connection_cb)); + ASSERT(0 == uv_tcp_init(uv_default_loop(), &server)); + ASSERT(0 == uv_tcp_bind(&server, (struct sockaddr*) &addr, 0)); + ASSERT(0 == uv_listen((uv_stream_t*) &server, 128, connection_cb)); } @@ -114,22 +114,22 @@ TEST_IMPL(tcp_try_write) { start_server(); - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); + ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); - ASSERT_OK(uv_tcp_init(uv_default_loop(), &client)); - ASSERT_OK(uv_tcp_connect(&connect_req, - &client, - (struct sockaddr*) &addr, - connect_cb)); + ASSERT(0 == uv_tcp_init(uv_default_loop(), &client)); + ASSERT(0 == uv_tcp_connect(&connect_req, + &client, + (struct sockaddr*) &addr, + connect_cb)); - ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT)); + ASSERT(0 == uv_run(uv_default_loop(), UV_RUN_DEFAULT)); - ASSERT_EQ(1, connect_cb_called); - ASSERT_EQ(3, close_cb_called); - ASSERT_EQ(1, connection_cb_called); - ASSERT_EQ(bytes_read, bytes_written); - ASSERT_GT(bytes_written, 0); + ASSERT(connect_cb_called == 1); + ASSERT(close_cb_called == 3); + ASSERT(connection_cb_called == 1); + ASSERT(bytes_read == bytes_written); + ASSERT(bytes_written > 0); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-tcp-unexpected-read.c b/test/test-tcp-unexpected-read.c index aef7a2f..c7b9814 100644 --- a/test/test-tcp-unexpected-read.c +++ b/test/test-tcp-unexpected-read.c @@ -60,14 +60,14 @@ static void read_cb(uv_stream_t* handle, ssize_t nread, const uv_buf_t* buf) { static void connect_cb(uv_connect_t* req, int status) { - ASSERT_PTR_EQ(req->handle, (uv_stream_t*) &client_handle); - ASSERT_OK(status); + ASSERT(req->handle == (uv_stream_t*) &client_handle); + ASSERT(0 == status); } static void write_cb(uv_write_t* req, int status) { - ASSERT_PTR_EQ(req->handle, (uv_stream_t*) &peer_handle); - ASSERT_OK(status); + ASSERT(req->handle == (uv_stream_t*) &peer_handle); + ASSERT(0 == status); } @@ -76,11 +76,11 @@ static void connection_cb(uv_stream_t* handle, int status) { buf = uv_buf_init("PING", 4); - ASSERT_OK(status); - ASSERT_OK(uv_accept(handle, (uv_stream_t*) &peer_handle)); - ASSERT_OK(uv_read_start((uv_stream_t*) &peer_handle, alloc_cb, read_cb)); - ASSERT_OK(uv_write(&write_req, (uv_stream_t*) &peer_handle, - &buf, 1, write_cb)); + ASSERT(0 == status); + ASSERT(0 == uv_accept(handle, (uv_stream_t*) &peer_handle)); + ASSERT(0 == uv_read_start((uv_stream_t*) &peer_handle, alloc_cb, read_cb)); + ASSERT(0 == uv_write(&write_req, (uv_stream_t*) &peer_handle, + &buf, 1, write_cb)); } @@ -88,30 +88,30 @@ TEST_IMPL(tcp_unexpected_read) { struct sockaddr_in addr; uv_loop_t* loop; - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); + ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); loop = uv_default_loop(); - ASSERT_OK(uv_timer_init(loop, &timer_handle)); - ASSERT_OK(uv_timer_start(&timer_handle, timer_cb, 1000, 0)); - ASSERT_OK(uv_check_init(loop, &check_handle)); - ASSERT_OK(uv_check_start(&check_handle, check_cb)); - ASSERT_OK(uv_tcp_init(loop, &server_handle)); - ASSERT_OK(uv_tcp_init(loop, &client_handle)); - ASSERT_OK(uv_tcp_init(loop, &peer_handle)); - ASSERT_OK(uv_tcp_bind(&server_handle, (const struct sockaddr*) &addr, 0)); - ASSERT_OK(uv_listen((uv_stream_t*) &server_handle, 1, connection_cb)); - ASSERT_OK(uv_tcp_connect(&connect_req, - &client_handle, - (const struct sockaddr*) &addr, - connect_cb)); - ASSERT_OK(uv_run(loop, UV_RUN_DEFAULT)); + ASSERT(0 == uv_timer_init(loop, &timer_handle)); + ASSERT(0 == uv_timer_start(&timer_handle, timer_cb, 1000, 0)); + ASSERT(0 == uv_check_init(loop, &check_handle)); + ASSERT(0 == uv_check_start(&check_handle, check_cb)); + ASSERT(0 == uv_tcp_init(loop, &server_handle)); + ASSERT(0 == uv_tcp_init(loop, &client_handle)); + ASSERT(0 == uv_tcp_init(loop, &peer_handle)); + ASSERT(0 == uv_tcp_bind(&server_handle, (const struct sockaddr*) &addr, 0)); + ASSERT(0 == uv_listen((uv_stream_t*) &server_handle, 1, connection_cb)); + ASSERT(0 == uv_tcp_connect(&connect_req, + &client_handle, + (const struct sockaddr*) &addr, + connect_cb)); + ASSERT(0 == uv_run(loop, UV_RUN_DEFAULT)); /* This is somewhat inexact but the idea is that the event loop should not * start busy looping when the server sends a message and the client isn't * reading. */ - ASSERT_LE(ticks, 20); + ASSERT(ticks <= 20); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-tcp-write-after-connect.c b/test/test-tcp-write-after-connect.c index 63845bc..8a698f4 100644 --- a/test/test-tcp-write-after-connect.c +++ b/test/test-tcp-write-after-connect.c @@ -32,13 +32,13 @@ uv_buf_t buf = { "HELLO", 4 }; static void write_cb(uv_write_t *req, int status) { - ASSERT_EQ(status, UV_ECANCELED); + ASSERT(status == UV_ECANCELED); uv_close((uv_handle_t*) req->handle, NULL); } static void connect_cb(uv_connect_t *req, int status) { - ASSERT_EQ(status, UV_ECONNREFUSED); + ASSERT(status == UV_ECONNREFUSED); } @@ -49,24 +49,24 @@ TEST_IMPL(tcp_write_after_connect) { #endif struct sockaddr_in sa; - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &sa)); - ASSERT_OK(uv_loop_init(&loop)); - ASSERT_OK(uv_tcp_init(&loop, &tcp_client)); + ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &sa)); + ASSERT(0 == uv_loop_init(&loop)); + ASSERT(0 == uv_tcp_init(&loop, &tcp_client)); - ASSERT_OK(uv_tcp_connect(&connection_request, - &tcp_client, - (const struct sockaddr *) - &sa, - connect_cb)); + ASSERT(0 == uv_tcp_connect(&connection_request, + &tcp_client, + (const struct sockaddr *) + &sa, + connect_cb)); - ASSERT_OK(uv_write(&write_request, - (uv_stream_t *)&tcp_client, - &buf, 1, - write_cb)); + ASSERT(0 == uv_write(&write_request, + (uv_stream_t *)&tcp_client, + &buf, 1, + write_cb)); uv_run(&loop, UV_RUN_DEFAULT); - MAKE_VALGRIND_HAPPY(&loop); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-tcp-write-fail.c b/test/test-tcp-write-fail.c index 530329a..58ee00f 100644 --- a/test/test-tcp-write-fail.c +++ b/test/test-tcp-write-fail.c @@ -41,13 +41,13 @@ static void close_socket(uv_tcp_t* sock) { int r; r = uv_fileno((uv_handle_t*)sock, &fd); - ASSERT_OK(r); + ASSERT(r == 0); #ifdef _WIN32 r = closesocket((uv_os_sock_t)fd); #else r = close(fd); #endif - ASSERT_OK(r); + ASSERT(r == 0); } @@ -60,7 +60,7 @@ static void close_cb(uv_handle_t* handle) { static void write_cb(uv_write_t* req, int status) { ASSERT_NOT_NULL(req); - ASSERT(status); + ASSERT(status != 0); fprintf(stderr, "uv_write error: %s\n", uv_strerror(status)); write_cb_called++; @@ -73,8 +73,8 @@ static void connect_cb(uv_connect_t* req, int status) { uv_stream_t* stream; int r; - ASSERT_PTR_EQ(req, &connect_req); - ASSERT_OK(status); + ASSERT(req == &connect_req); + ASSERT(status == 0); stream = req->handle; connect_cb_called++; @@ -84,7 +84,7 @@ static void connect_cb(uv_connect_t* req, int status) { buf = uv_buf_init("hello\n", 6); r = uv_write(&write_req, stream, &buf, 1, write_cb); - ASSERT_OK(r); + ASSERT(r == 0); } @@ -93,23 +93,23 @@ TEST_IMPL(tcp_write_fail) { uv_tcp_t client; int r; - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); + ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); r = uv_tcp_init(uv_default_loop(), &client); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_tcp_connect(&connect_req, &client, (const struct sockaddr*) &addr, connect_cb); - ASSERT_OK(r); + ASSERT(r == 0); uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_EQ(1, connect_cb_called); - ASSERT_EQ(1, write_cb_called); - ASSERT_EQ(1, close_cb_called); + ASSERT(connect_cb_called == 1); + ASSERT(write_cb_called == 1); + ASSERT(close_cb_called == 1); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-tcp-write-in-a-row.c b/test/test-tcp-write-in-a-row.c deleted file mode 100644 index 5c17ed4..0000000 --- a/test/test-tcp-write-in-a-row.c +++ /dev/null @@ -1,143 +0,0 @@ -/* Copyright libuv project contributors. All rights reserved. - * - * Permission is hereby granted, free of charge, to any person obtaining a copy - * of this software and associated documentation files (the "Software"), to - * deal in the Software without restriction, including without limitation the - * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or - * sell copies of the Software, and to permit persons to whom the Software is - * furnished to do so, subject to the following conditions: - * - * The above copyright notice and this permission notice shall be included in - * all copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING - * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS - * IN THE SOFTWARE. - */ - -#include -#include -#include - -#include "task.h" -#include "uv.h" - -static uv_tcp_t server; -static uv_tcp_t client; -static uv_tcp_t incoming; -static int connect_cb_called; -static int close_cb_called; -static int connection_cb_called; -static int write_cb_called; -static uv_write_t small_write; -static uv_write_t big_write; - -/* 10 MB, which is large than the send buffer size and the recv buffer */ -static char data[1024 * 1024 * 10]; - -static void close_cb(uv_handle_t* handle) { - close_cb_called++; -} - -static void write_cb(uv_write_t* w, int status) { - /* the small write should finish immediately after the big write */ - ASSERT_OK(uv_stream_get_write_queue_size((uv_stream_t*) &client)); - - write_cb_called++; - - if (write_cb_called == 2) { - /* we are done */ - uv_close((uv_handle_t*) &client, close_cb); - uv_close((uv_handle_t*) &incoming, close_cb); - uv_close((uv_handle_t*) &server, close_cb); - } -} - -static void connect_cb(uv_connect_t* _, int status) { - int r; - uv_buf_t buf; - size_t write_queue_size0, write_queue_size1; - - ASSERT_OK(status); - connect_cb_called++; - - /* fire a big write */ - buf = uv_buf_init(data, sizeof(data)); - r = uv_write(&small_write, (uv_stream_t*) &client, &buf, 1, write_cb); - ASSERT_OK(r); - - /* check that the write process gets stuck */ - write_queue_size0 = uv_stream_get_write_queue_size((uv_stream_t*) &client); - ASSERT_GT(write_queue_size0, 0); - - /* fire a small write, which should be queued */ - buf = uv_buf_init("A", 1); - r = uv_write(&big_write, (uv_stream_t*) &client, &buf, 1, write_cb); - ASSERT_OK(r); - - write_queue_size1 = uv_stream_get_write_queue_size((uv_stream_t*) &client); - ASSERT_EQ(write_queue_size1, write_queue_size0 + 1); -} - -static void alloc_cb(uv_handle_t* handle, size_t size, uv_buf_t* buf) { - static char base[1024]; - - buf->base = base; - buf->len = sizeof(base); -} - -static void read_cb(uv_stream_t* tcp, ssize_t nread, const uv_buf_t* buf) {} - -static void connection_cb(uv_stream_t* tcp, int status) { - ASSERT_OK(status); - connection_cb_called++; - - ASSERT_OK(uv_tcp_init(tcp->loop, &incoming)); - ASSERT_OK(uv_accept(tcp, (uv_stream_t*) &incoming)); - ASSERT_OK(uv_read_start((uv_stream_t*) &incoming, alloc_cb, read_cb)); -} - -static void start_server(void) { - struct sockaddr_in addr; - - ASSERT_OK(uv_ip4_addr("0.0.0.0", TEST_PORT, &addr)); - - ASSERT_OK(uv_tcp_init(uv_default_loop(), &server)); - ASSERT_OK(uv_tcp_bind(&server, (struct sockaddr*) &addr, 0)); - ASSERT_OK(uv_listen((uv_stream_t*) &server, 128, connection_cb)); -} - -TEST_IMPL(tcp_write_in_a_row) { -#if defined(_WIN32) - RETURN_SKIP("tcp_write_in_a_row does not work on Windows"); -#elif defined(__PASE__) - RETURN_SKIP("tcp_write_in_a_row does not work on IBM i PASE"); -#else - uv_connect_t connect_req; - struct sockaddr_in addr; - - start_server(); - - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); - - ASSERT_OK(uv_tcp_init(uv_default_loop(), &client)); - ASSERT_OK(uv_tcp_connect(&connect_req, - &client, - (struct sockaddr*) &addr, - connect_cb)); - - ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT)); - - ASSERT_EQ(1, connect_cb_called); - ASSERT_EQ(3, close_cb_called); - ASSERT_EQ(1, connection_cb_called); - ASSERT_EQ(2, write_cb_called); - - MAKE_VALGRIND_HAPPY(uv_default_loop()); - return 0; -#endif -} diff --git a/test/test-tcp-write-queue-order.c b/test/test-tcp-write-queue-order.c index e838c88..1ff9c51 100644 --- a/test/test-tcp-write-queue-order.c +++ b/test/test-tcp-write-queue-order.c @@ -67,7 +67,7 @@ static void connect_cb(uv_connect_t* req, int status) { int i; uv_buf_t buf; - ASSERT_OK(status); + ASSERT(status == 0); connect_cb_called++; buf = uv_buf_init(base, sizeof(base)); @@ -78,19 +78,19 @@ static void connect_cb(uv_connect_t* req, int status) { &buf, 1, write_cb); - ASSERT_OK(r); + ASSERT(r == 0); } } static void connection_cb(uv_stream_t* tcp, int status) { - ASSERT_OK(status); + ASSERT(status == 0); - ASSERT_OK(uv_tcp_init(tcp->loop, &incoming)); - ASSERT_OK(uv_accept(tcp, (uv_stream_t*) &incoming)); + ASSERT(0 == uv_tcp_init(tcp->loop, &incoming)); + ASSERT(0 == uv_accept(tcp, (uv_stream_t*) &incoming)); - ASSERT_OK(uv_timer_init(uv_default_loop(), &timer)); - ASSERT_OK(uv_timer_start(&timer, timer_cb, 1000, 0)); + ASSERT(0 == uv_timer_init(uv_default_loop(), &timer)); + ASSERT(0 == uv_timer_start(&timer, timer_cb, 1000, 0)); connection_cb_called++; } @@ -99,11 +99,11 @@ static void connection_cb(uv_stream_t* tcp, int status) { static void start_server(void) { struct sockaddr_in addr; - ASSERT_OK(uv_ip4_addr("0.0.0.0", TEST_PORT, &addr)); + ASSERT(0 == uv_ip4_addr("0.0.0.0", TEST_PORT, &addr)); - ASSERT_OK(uv_tcp_init(uv_default_loop(), &server)); - ASSERT_OK(uv_tcp_bind(&server, (struct sockaddr*) &addr, 0)); - ASSERT_OK(uv_listen((uv_stream_t*) &server, 128, connection_cb)); + ASSERT(0 == uv_tcp_init(uv_default_loop(), &server)); + ASSERT(0 == uv_tcp_bind(&server, (struct sockaddr*) &addr, 0)); + ASSERT(0 == uv_listen((uv_stream_t*) &server, 128, connection_cb)); } @@ -114,26 +114,26 @@ TEST_IMPL(tcp_write_queue_order) { start_server(); - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); + ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); - ASSERT_OK(uv_tcp_init(uv_default_loop(), &client)); - ASSERT_OK(uv_tcp_connect(&connect_req, - &client, - (struct sockaddr*) &addr, - connect_cb)); - ASSERT_OK(uv_send_buffer_size((uv_handle_t*) &client, &buffer_size)); + ASSERT(0 == uv_tcp_init(uv_default_loop(), &client)); + ASSERT(0 == uv_tcp_connect(&connect_req, + &client, + (struct sockaddr*) &addr, + connect_cb)); + ASSERT(0 == uv_send_buffer_size((uv_handle_t*) &client, &buffer_size)); - ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT)); + ASSERT(0 == uv_run(uv_default_loop(), UV_RUN_DEFAULT)); - ASSERT_EQ(1, connect_cb_called); - ASSERT_EQ(1, connection_cb_called); - ASSERT_GT(write_callbacks, 0); - ASSERT_GT(write_cancelled_callbacks, 0); - ASSERT_EQ(write_callbacks + - write_error_callbacks + - write_cancelled_callbacks, REQ_COUNT); - ASSERT_EQ(3, close_cb_called); + ASSERT(connect_cb_called == 1); + ASSERT(connection_cb_called == 1); + ASSERT(write_callbacks > 0); + ASSERT(write_cancelled_callbacks > 0); + ASSERT(write_callbacks + + write_error_callbacks + + write_cancelled_callbacks == REQ_COUNT); + ASSERT(close_cb_called == 3); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-tcp-write-to-half-open-connection.c b/test/test-tcp-write-to-half-open-connection.c index 2b2f564..ae42513 100644 --- a/test/test-tcp-write-to-half-open-connection.c +++ b/test/test-tcp-write-to-half-open-connection.c @@ -45,23 +45,23 @@ static void connection_cb(uv_stream_t* server, int status) { int r; uv_buf_t buf; - ASSERT_PTR_EQ(server, (uv_stream_t*)&tcp_server); - ASSERT_OK(status); + ASSERT(server == (uv_stream_t*)&tcp_server); + ASSERT(status == 0); r = uv_tcp_init(server->loop, &tcp_peer); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_accept(server, (uv_stream_t*)&tcp_peer); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_read_start((uv_stream_t*)&tcp_peer, alloc_cb, read_cb); - ASSERT_OK(r); + ASSERT(r == 0); buf.base = "hello\n"; buf.len = 6; r = uv_write(&write_req, (uv_stream_t*)&tcp_peer, &buf, 1, write_cb); - ASSERT_OK(r); + ASSERT(r == 0); } @@ -88,8 +88,8 @@ static void read_cb(uv_stream_t* stream, ssize_t nread, const uv_buf_t* buf) { static void connect_cb(uv_connect_t* req, int status) { - ASSERT_PTR_EQ(req, &connect_req); - ASSERT_OK(status); + ASSERT(req == &connect_req); + ASSERT(status == 0); /* Close the client. */ uv_close((uv_handle_t*)&tcp_client, NULL); @@ -97,7 +97,7 @@ static void connect_cb(uv_connect_t* req, int status) { static void write_cb(uv_write_t* req, int status) { - ASSERT_OK(status); + ASSERT(status == 0); write_cb_called++; } @@ -107,35 +107,35 @@ TEST_IMPL(tcp_write_to_half_open_connection) { uv_loop_t* loop; int r; - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); + ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); loop = uv_default_loop(); ASSERT_NOT_NULL(loop); r = uv_tcp_init(loop, &tcp_server); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_tcp_bind(&tcp_server, (const struct sockaddr*) &addr, 0); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_listen((uv_stream_t*)&tcp_server, 1, connection_cb); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_tcp_init(loop, &tcp_client); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_tcp_connect(&connect_req, &tcp_client, (const struct sockaddr*) &addr, connect_cb); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_run(loop, UV_RUN_DEFAULT); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_GT(write_cb_called, 0); - ASSERT_GT(read_cb_called, 0); + ASSERT(write_cb_called > 0); + ASSERT(read_cb_called > 0); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-tcp-writealot.c b/test/test-tcp-writealot.c index fbfa498..40dce96 100644 --- a/test/test-tcp-writealot.c +++ b/test/test-tcp-writealot.c @@ -65,19 +65,19 @@ static void close_cb(uv_handle_t* handle) { static void shutdown_cb(uv_shutdown_t* req, int status) { uv_tcp_t* tcp; - ASSERT_PTR_EQ(req, &shutdown_req); - ASSERT_OK(status); + ASSERT(req == &shutdown_req); + ASSERT(status == 0); tcp = (uv_tcp_t*)(req->handle); /* The write buffer should be empty by now. */ - ASSERT_OK(tcp->write_queue_size); + ASSERT(tcp->write_queue_size == 0); /* Now we wait for the EOF */ shutdown_cb_called++; /* We should have had all the writes called already. */ - ASSERT_EQ(write_cb_called, WRITES); + ASSERT(write_cb_called == WRITES); } @@ -88,7 +88,7 @@ static void read_cb(uv_stream_t* tcp, ssize_t nread, const uv_buf_t* buf) { bytes_received_done += nread; } else { - ASSERT_EQ(nread, UV_EOF); + ASSERT(nread == UV_EOF); printf("GOT EOF\n"); uv_close((uv_handle_t*)tcp, close_cb); } @@ -115,8 +115,8 @@ static void connect_cb(uv_connect_t* req, int status) { uv_stream_t* stream; int i, j, r; - ASSERT_PTR_EQ(req, &connect_req); - ASSERT_OK(status); + ASSERT(req == &connect_req); + ASSERT(status == 0); stream = req->handle; connect_cb_called++; @@ -131,16 +131,16 @@ static void connect_cb(uv_connect_t* req, int status) { } r = uv_write(write_req, stream, send_bufs, CHUNKS_PER_WRITE, write_cb); - ASSERT_OK(r); + ASSERT(r == 0); } /* Shutdown on drain. */ r = uv_shutdown(&shutdown_req, stream, shutdown_cb); - ASSERT_OK(r); + ASSERT(r == 0); /* Start reading */ r = uv_read_start(stream, alloc_cb, read_cb); - ASSERT_OK(r); + ASSERT(r == 0); } @@ -149,37 +149,32 @@ TEST_IMPL(tcp_writealot) { uv_tcp_t client; int r; -#if defined(__MSAN__) || defined(__TSAN__) - RETURN_SKIP("Test is too slow to run under " - "MemorySanitizer or ThreadSanitizer"); -#endif - - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); + ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); send_buffer = calloc(1, TOTAL_BYTES); ASSERT_NOT_NULL(send_buffer); r = uv_tcp_init(uv_default_loop(), &client); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_tcp_connect(&connect_req, &client, (const struct sockaddr*) &addr, connect_cb); - ASSERT_OK(r); + ASSERT(r == 0); uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_EQ(1, shutdown_cb_called); - ASSERT_EQ(1, connect_cb_called); - ASSERT_EQ(write_cb_called, WRITES); - ASSERT_EQ(1, close_cb_called); - ASSERT_EQ(bytes_sent, TOTAL_BYTES); - ASSERT_EQ(bytes_sent_done, TOTAL_BYTES); - ASSERT_EQ(bytes_received_done, TOTAL_BYTES); + ASSERT(shutdown_cb_called == 1); + ASSERT(connect_cb_called == 1); + ASSERT(write_cb_called == WRITES); + ASSERT(close_cb_called == 1); + ASSERT(bytes_sent == TOTAL_BYTES); + ASSERT(bytes_sent_done == TOTAL_BYTES); + ASSERT(bytes_received_done == TOTAL_BYTES); free(send_buffer); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-thread-affinity.c b/test/test-thread-affinity.c deleted file mode 100644 index d21487d..0000000 --- a/test/test-thread-affinity.c +++ /dev/null @@ -1,154 +0,0 @@ -/* Copyright libuv project contributors. All rights reserved. - * - * Permission is hereby granted, free of charge, to any person obtaining a copy - * of this software and associated documentation files (the "Software"), to - * deal in the Software without restriction, including without limitation the - * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or - * sell copies of the Software, and to permit persons to whom the Software is - * furnished to do so, subject to the following conditions: - * - * The above copyright notice and this permission notice shall be included in - * all copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING - * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS - * IN THE SOFTWARE. - */ - -#include "uv.h" -#include "task.h" - -#include - -#ifndef NO_CPU_AFFINITY - -static void check_affinity(void* arg) { - int r; - char* cpumask; - int cpumasksize; - uv_thread_t tid; - - cpumask = (char*)arg; - cpumasksize = uv_cpumask_size(); - ASSERT_GT(cpumasksize, 0); - tid = uv_thread_self(); - r = uv_thread_setaffinity(&tid, cpumask, NULL, cpumasksize); - ASSERT_OK(r); - r = uv_thread_setaffinity(&tid, cpumask + cpumasksize, cpumask, cpumasksize); - ASSERT_OK(r); -} - - -TEST_IMPL(thread_affinity) { - int t1first; - int t1second; - int t2first; - int t2second; - int cpumasksize; - char* cpumask; - int ncpus; - int r; - int c; - int i; - uv_thread_t threads[3]; - -#ifdef _WIN32 - /* uv_thread_self isn't defined for the main thread on Windows */ - threads[0] = GetCurrentThread(); -#else - threads[0] = uv_thread_self(); -#endif - cpumasksize = uv_cpumask_size(); - ASSERT_GT(cpumasksize, 0); - - cpumask = calloc(4 * cpumasksize, 1); - ASSERT(cpumask); - - r = uv_thread_getaffinity(&threads[0], cpumask, cpumasksize); - ASSERT_OK(r); - ASSERT(cpumask[0] && "test must be run with cpu 0 affinity"); - ncpus = 0; - while (cpumask[++ncpus]) { } - memset(cpumask, 0, 4 * cpumasksize); - - t1first = cpumasksize * 0; - t1second = cpumasksize * 1; - t2first = cpumasksize * 2; - t2second = cpumasksize * 3; - - cpumask[t1second + 0] = 1; - cpumask[t2first + 0] = 1; - cpumask[t1first + (ncpus >= 2)] = 1; - cpumask[t2second + (ncpus >= 2)] = 1; -#ifdef __linux__ - cpumask[t1second + 2] = 1; - cpumask[t2first + 2] = 1; - cpumask[t1first + 3] = 1; - cpumask[t2second + 3] = 1; -#else - if (ncpus >= 3) { - cpumask[t1second + 2] = 1; - cpumask[t2first + 2] = 1; - } - if (ncpus >= 4) { - cpumask[t1first + 3] = 1; - cpumask[t2second + 3] = 1; - } -#endif - - ASSERT_OK(uv_thread_create(threads + 1, - check_affinity, - &cpumask[t1first])); - ASSERT_OK(uv_thread_create(threads + 2, - check_affinity, - &cpumask[t2first])); - ASSERT_OK(uv_thread_join(threads + 1)); - ASSERT_OK(uv_thread_join(threads + 2)); - - ASSERT(cpumask[t1first + 0] == (ncpus == 1)); - ASSERT(cpumask[t1first + 1] == (ncpus >= 2)); - ASSERT_OK(cpumask[t1first + 2]); - ASSERT(cpumask[t1first + 3] == (ncpus >= 4)); - - ASSERT_EQ(1, cpumask[t2first + 0]); - ASSERT_OK(cpumask[t2first + 1]); - ASSERT(cpumask[t2first + 2] == (ncpus >= 3)); - ASSERT_OK(cpumask[t2first + 3]); - - c = uv_thread_getcpu(); - ASSERT_GE(c, 0); - - memset(cpumask, 0, cpumasksize); - cpumask[c] = 1; - r = uv_thread_setaffinity(&threads[0], cpumask, NULL, cpumasksize); - ASSERT_OK(r); - - memset(cpumask, 0, cpumasksize); - r = uv_thread_getaffinity(&threads[0], cpumask, cpumasksize); - ASSERT_OK(r); - for (i = 0; i < cpumasksize; i++) { - if (i == c) - ASSERT_EQ(1, cpumask[i]); - else - ASSERT_OK(cpumask[i]); - } - - free(cpumask); - - return 0; -} - -#else - -TEST_IMPL(thread_affinity) { - int cpumasksize; - cpumasksize = uv_cpumask_size(); - ASSERT_EQ(cpumasksize, UV_ENOTSUP); - return 0; -} - -#endif diff --git a/test/test-thread-equal.c b/test/test-thread-equal.c index 3b2ba8d..f7bde71 100644 --- a/test/test-thread-equal.c +++ b/test/test-thread-equal.c @@ -31,7 +31,7 @@ static void check_thread(void* arg) { #ifdef _WIN32 ASSERT_NOT_NULL(self_id); #endif - ASSERT_OK(uv_thread_equal(&main_thread_id, &self_id)); + ASSERT(uv_thread_equal(&main_thread_id, &self_id) == 0); *thread_id = uv_thread_self(); } @@ -41,11 +41,11 @@ TEST_IMPL(thread_equal) { #ifdef _WIN32 ASSERT_NOT_NULL(main_thread_id); #endif - ASSERT_NE(0, uv_thread_equal(&main_thread_id, &main_thread_id)); - ASSERT_OK(uv_thread_create(threads + 0, check_thread, subthreads + 0)); - ASSERT_OK(uv_thread_create(threads + 1, check_thread, subthreads + 1)); - ASSERT_OK(uv_thread_join(threads + 0)); - ASSERT_OK(uv_thread_join(threads + 1)); - ASSERT_OK(uv_thread_equal(subthreads + 0, subthreads + 1)); + ASSERT(0 != uv_thread_equal(&main_thread_id, &main_thread_id)); + ASSERT(0 == uv_thread_create(threads + 0, check_thread, subthreads + 0)); + ASSERT(0 == uv_thread_create(threads + 1, check_thread, subthreads + 1)); + ASSERT(0 == uv_thread_join(threads + 0)); + ASSERT(0 == uv_thread_join(threads + 1)); + ASSERT(0 == uv_thread_equal(subthreads + 0, subthreads + 1)); return 0; } diff --git a/test/test-thread.c b/test/test-thread.c index d0094e3..40d645d 100644 --- a/test/test-thread.c +++ b/test/test-thread.c @@ -71,17 +71,19 @@ static void getaddrinfo_do(struct getaddrinfo_req* req) { "localhost", NULL, NULL); - ASSERT_OK(r); + ASSERT(r == 0); } static void getaddrinfo_cb(uv_getaddrinfo_t* handle, int status, struct addrinfo* res) { +/* TODO(gengjiawen): Fix test on QEMU. */ +#if defined(__QEMU__) + RETURN_SKIP("Test does not currently work in QEMU"); +#endif struct getaddrinfo_req* req; - ASSERT_OK(status); - req = container_of(handle, struct getaddrinfo_req, handle); uv_freeaddrinfo(res); @@ -94,7 +96,7 @@ static void fs_do(struct fs_req* req) { int r; r = uv_fs_stat(req->loop, &req->handle, ".", fs_cb); - ASSERT_OK(r); + ASSERT(r == 0); } @@ -108,37 +110,8 @@ static void fs_cb(uv_fs_t* handle) { } -static void do_work(void* arg) { - struct getaddrinfo_req getaddrinfo_reqs[4]; - struct fs_req fs_reqs[4]; - uv_loop_t loop; - size_t i; - struct test_thread* thread = arg; - - ASSERT_OK(uv_loop_init(&loop)); - - for (i = 0; i < ARRAY_SIZE(getaddrinfo_reqs); i++) { - struct getaddrinfo_req* req = getaddrinfo_reqs + i; - req->counter = 4; - req->loop = &loop; - getaddrinfo_do(req); - } - - for (i = 0; i < ARRAY_SIZE(fs_reqs); i++) { - struct fs_req* req = fs_reqs + i; - req->counter = 4; - req->loop = &loop; - fs_do(req); - } - - ASSERT_OK(uv_run(&loop, UV_RUN_DEFAULT)); - ASSERT_OK(uv_loop_close(&loop)); - thread->thread_called = 1; -} - - static void thread_entry(void* arg) { - ASSERT_PTR_EQ(arg, (void *) 42); + ASSERT(arg == (void *) 42); thread_called++; } @@ -148,42 +121,12 @@ TEST_IMPL(thread_create) { int r; r = uv_thread_create(&tid, thread_entry, (void *) 42); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_thread_join(&tid); - ASSERT_OK(r); - - ASSERT_EQ(1, thread_called); - - return 0; -} - - -/* Hilariously bad test name. Run a lot of tasks in the thread pool and verify - * 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; - - memset(threads, 0, sizeof(threads)); - - for (i = 0; i < ARRAY_SIZE(threads); i++) { - r = uv_thread_create(&threads[i].thread_id, do_work, &threads[i]); - ASSERT_OK(r); - } + ASSERT(r == 0); - for (i = 0; i < ARRAY_SIZE(threads); i++) { - r = uv_thread_join(&threads[i].thread_id); - ASSERT_OK(r); - ASSERT_EQ(1, threads[i].thread_called); - } + ASSERT(thread_called == 1); return 0; } @@ -192,7 +135,7 @@ TEST_IMPL(threadpool_multiple_event_loops) { static void tls_thread(void* arg) { ASSERT_NULL(uv_key_get(&tls_key)); uv_key_set(&tls_key, arg); - ASSERT_PTR_EQ(arg, uv_key_get(&tls_key)); + ASSERT(arg == uv_key_get(&tls_key)); uv_key_set(&tls_key, NULL); ASSERT_NULL(uv_key_get(&tls_key)); } @@ -201,14 +144,14 @@ static void tls_thread(void* arg) { TEST_IMPL(thread_local_storage) { char name[] = "main"; uv_thread_t threads[2]; - ASSERT_OK(uv_key_create(&tls_key)); + ASSERT(0 == uv_key_create(&tls_key)); ASSERT_NULL(uv_key_get(&tls_key)); uv_key_set(&tls_key, name); - ASSERT_PTR_EQ(name, uv_key_get(&tls_key)); - ASSERT_OK(uv_thread_create(threads + 0, tls_thread, threads + 0)); - ASSERT_OK(uv_thread_create(threads + 1, tls_thread, threads + 1)); - ASSERT_OK(uv_thread_join(threads + 0)); - ASSERT_OK(uv_thread_join(threads + 1)); + ASSERT(name == uv_key_get(&tls_key)); + ASSERT(0 == uv_thread_create(threads + 0, tls_thread, threads + 0)); + ASSERT(0 == uv_thread_create(threads + 1, tls_thread, threads + 1)); + ASSERT(0 == uv_thread_join(threads + 0)); + ASSERT(0 == uv_thread_join(threads + 1)); uv_key_delete(&tls_key); return 0; } @@ -222,30 +165,30 @@ static void thread_check_stack(void* arg) { * on MacOS. */ if (expected == 0) expected = 512 * 1024; - ASSERT_GE(pthread_get_stacksize_np(pthread_self()), expected); + ASSERT(pthread_get_stacksize_np(pthread_self()) >= expected); #elif defined(__linux__) && defined(__GLIBC__) size_t expected; struct rlimit lim; size_t stack_size; pthread_attr_t attr; - ASSERT_OK(getrlimit(RLIMIT_STACK, &lim)); + ASSERT(0 == getrlimit(RLIMIT_STACK, &lim)); if (lim.rlim_cur == RLIM_INFINITY) lim.rlim_cur = 2 << 20; /* glibc default. */ - ASSERT_OK(pthread_getattr_np(pthread_self(), &attr)); - ASSERT_OK(pthread_attr_getstacksize(&attr, &stack_size)); + ASSERT(0 == pthread_getattr_np(pthread_self(), &attr)); + ASSERT(0 == pthread_attr_getstacksize(&attr, &stack_size)); expected = arg == NULL ? 0 : ((uv_thread_options_t*)arg)->stack_size; if (expected == 0) expected = (size_t)lim.rlim_cur; - ASSERT_GE(stack_size, expected); - ASSERT_OK(pthread_attr_destroy(&attr)); + ASSERT(stack_size >= expected); + ASSERT(0 == pthread_attr_destroy(&attr)); #endif } TEST_IMPL(thread_stack_size) { uv_thread_t thread; - ASSERT_OK(uv_thread_create(&thread, thread_check_stack, NULL)); - ASSERT_OK(uv_thread_join(&thread)); + ASSERT(0 == uv_thread_create(&thread, thread_check_stack, NULL)); + ASSERT(0 == uv_thread_join(&thread)); return 0; } @@ -255,42 +198,42 @@ TEST_IMPL(thread_stack_size_explicit) { options.flags = UV_THREAD_HAS_STACK_SIZE; options.stack_size = 1024 * 1024; - ASSERT_OK(uv_thread_create_ex(&thread, &options, - thread_check_stack, &options)); - ASSERT_OK(uv_thread_join(&thread)); + ASSERT(0 == uv_thread_create_ex(&thread, &options, + thread_check_stack, &options)); + ASSERT(0 == uv_thread_join(&thread)); options.stack_size = 8 * 1024 * 1024; /* larger than most default os sizes */ - ASSERT_OK(uv_thread_create_ex(&thread, &options, - thread_check_stack, &options)); - ASSERT_OK(uv_thread_join(&thread)); + ASSERT(0 == uv_thread_create_ex(&thread, &options, + thread_check_stack, &options)); + ASSERT(0 == uv_thread_join(&thread)); options.stack_size = 0; - ASSERT_OK(uv_thread_create_ex(&thread, &options, - thread_check_stack, &options)); - ASSERT_OK(uv_thread_join(&thread)); + ASSERT(0 == uv_thread_create_ex(&thread, &options, + thread_check_stack, &options)); + ASSERT(0 == uv_thread_join(&thread)); options.stack_size = 42; - ASSERT_OK(uv_thread_create_ex(&thread, &options, - thread_check_stack, &options)); - ASSERT_OK(uv_thread_join(&thread)); + ASSERT(0 == uv_thread_create_ex(&thread, &options, + thread_check_stack, &options)); + ASSERT(0 == uv_thread_join(&thread)); #ifdef PTHREAD_STACK_MIN options.stack_size = PTHREAD_STACK_MIN - 42; /* unaligned size */ - ASSERT_OK(uv_thread_create_ex(&thread, &options, - thread_check_stack, &options)); - ASSERT_OK(uv_thread_join(&thread)); + ASSERT(0 == uv_thread_create_ex(&thread, &options, + thread_check_stack, &options)); + ASSERT(0 == uv_thread_join(&thread)); options.stack_size = PTHREAD_STACK_MIN / 2 - 42; /* unaligned size */ - ASSERT_OK(uv_thread_create_ex(&thread, &options, - thread_check_stack, &options)); - ASSERT_OK(uv_thread_join(&thread)); + ASSERT(0 == uv_thread_create_ex(&thread, &options, + thread_check_stack, &options)); + ASSERT(0 == uv_thread_join(&thread)); #endif /* unaligned size, should be larger than PTHREAD_STACK_MIN */ options.stack_size = 1234567; - ASSERT_OK(uv_thread_create_ex(&thread, &options, - thread_check_stack, &options)); - ASSERT_OK(uv_thread_join(&thread)); + ASSERT(0 == uv_thread_create_ex(&thread, &options, + thread_check_stack, &options)); + ASSERT(0 == uv_thread_join(&thread)); return 0; } diff --git a/test/test-threadpool-cancel.c b/test/test-threadpool-cancel.c index 544fbbc..1e867c5 100644 --- a/test/test-threadpool-cancel.c +++ b/test/test-threadpool-cancel.c @@ -22,10 +22,6 @@ #include "uv.h" #include "task.h" -#ifdef _WIN32 -# define putenv _putenv -#endif - #define INIT_CANCEL_INFO(ci, what) \ do { \ (ci)->reqs = (what); \ @@ -77,8 +73,8 @@ static void saturate_threadpool(void) { loop = uv_default_loop(); for (i = 0; i < ARRAY_SIZE(pause_reqs); i += 1) { - ASSERT_OK(uv_sem_init(pause_sems + i, 0)); - ASSERT_OK(uv_queue_work(loop, pause_reqs + i, work_cb, done_cb)); + ASSERT(0 == uv_sem_init(pause_sems + i, 0)); + ASSERT(0 == uv_queue_work(loop, pause_reqs + i, work_cb, done_cb)); } } @@ -91,40 +87,8 @@ static void unblock_threadpool(void) { } -static int known_broken(uv_req_t* req) { - if (req->type != UV_FS) - return 0; - -#ifdef __linux__ - /* TODO(bnoordhuis) make cancellation work with io_uring */ - switch (((uv_fs_t*) req)->fs_type) { - case UV_FS_CLOSE: - case UV_FS_FDATASYNC: - case UV_FS_FSTAT: - case UV_FS_FSYNC: - case UV_FS_LINK: - case UV_FS_LSTAT: - case UV_FS_MKDIR: - case UV_FS_OPEN: - case UV_FS_READ: - case UV_FS_RENAME: - case UV_FS_STAT: - case UV_FS_SYMLINK: - case UV_FS_WRITE: - case UV_FS_UNLINK: - return 1; - default: /* Squelch -Wswitch warnings. */ - break; - } -#endif - - return 0; -} - - static void fs_cb(uv_fs_t* req) { - ASSERT_NE(known_broken((uv_req_t*) req) || \ - req->result == UV_ECANCELED, 0); + ASSERT(req->result == UV_ECANCELED); uv_fs_req_cleanup(req); fs_cb_called++; } @@ -133,7 +97,7 @@ static void fs_cb(uv_fs_t* req) { static void getaddrinfo_cb(uv_getaddrinfo_t* req, int status, struct addrinfo* res) { - ASSERT_EQ(status, UV_EAI_CANCELED); + ASSERT(status == UV_EAI_CANCELED); ASSERT_NULL(res); uv_freeaddrinfo(res); /* Should not crash. */ } @@ -143,7 +107,7 @@ static void getnameinfo_cb(uv_getnameinfo_t* handle, int status, const char* hostname, const char* service) { - ASSERT_EQ(status, UV_EAI_CANCELED); + ASSERT(status == UV_EAI_CANCELED); ASSERT_NULL(hostname); ASSERT_NULL(service); } @@ -155,7 +119,7 @@ static void work2_cb(uv_work_t* req) { static void done2_cb(uv_work_t* req, int status) { - ASSERT_EQ(status, UV_ECANCELED); + ASSERT(status == UV_ECANCELED); done2_cb_called++; } @@ -169,7 +133,7 @@ static void timer_cb(uv_timer_t* handle) { for (i = 0; i < ci->nreqs; i++) { req = (uv_req_t*) ((char*) ci->reqs + i * ci->stride); - ASSERT(known_broken(req) || 0 == uv_cancel(req)); + ASSERT(0 == uv_cancel(req)); } uv_close((uv_handle_t*) &ci->timer_handle, NULL); @@ -179,7 +143,7 @@ static void timer_cb(uv_timer_t* handle) { static void nop_done_cb(uv_work_t* req, int status) { - ASSERT_EQ(status, UV_ECANCELED); + ASSERT(status == UV_ECANCELED); done_cb_called++; } @@ -189,9 +153,9 @@ static void nop_random_cb(uv_random_t* req, int status, void* buf, size_t len) { ri = container_of(req, struct random_info, random_req); - ASSERT_EQ(status, UV_ECANCELED); - ASSERT_PTR_EQ(buf, (void*) ri->buf); - ASSERT_EQ(len, sizeof(ri->buf)); + ASSERT(status == UV_ECANCELED); + ASSERT(buf == (void*) ri->buf); + ASSERT(len == sizeof(ri->buf)); done_cb_called++; } @@ -209,23 +173,23 @@ TEST_IMPL(threadpool_cancel_getaddrinfo) { saturate_threadpool(); r = uv_getaddrinfo(loop, reqs + 0, getaddrinfo_cb, "fail", NULL, NULL); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_getaddrinfo(loop, reqs + 1, getaddrinfo_cb, NULL, "fail", NULL); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_getaddrinfo(loop, reqs + 2, getaddrinfo_cb, "fail", "fail", NULL); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_getaddrinfo(loop, reqs + 3, getaddrinfo_cb, "fail", NULL, &hints); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_OK(uv_timer_init(loop, &ci.timer_handle)); - ASSERT_OK(uv_timer_start(&ci.timer_handle, timer_cb, 10, 0)); - ASSERT_OK(uv_run(loop, UV_RUN_DEFAULT)); - ASSERT_EQ(1, timer_cb_called); + ASSERT(0 == uv_timer_init(loop, &ci.timer_handle)); + ASSERT(0 == uv_timer_start(&ci.timer_handle, timer_cb, 10, 0)); + ASSERT(0 == uv_run(loop, UV_RUN_DEFAULT)); + ASSERT(1 == timer_cb_called); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -238,30 +202,30 @@ TEST_IMPL(threadpool_cancel_getnameinfo) { int r; r = uv_ip4_addr("127.0.0.1", 80, &addr4); - ASSERT_OK(r); + ASSERT(r == 0); INIT_CANCEL_INFO(&ci, reqs); loop = uv_default_loop(); saturate_threadpool(); r = uv_getnameinfo(loop, reqs + 0, getnameinfo_cb, (const struct sockaddr*)&addr4, 0); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_getnameinfo(loop, reqs + 1, getnameinfo_cb, (const struct sockaddr*)&addr4, 0); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_getnameinfo(loop, reqs + 2, getnameinfo_cb, (const struct sockaddr*)&addr4, 0); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_getnameinfo(loop, reqs + 3, getnameinfo_cb, (const struct sockaddr*)&addr4, 0); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_OK(uv_timer_init(loop, &ci.timer_handle)); - ASSERT_OK(uv_timer_start(&ci.timer_handle, timer_cb, 10, 0)); - ASSERT_OK(uv_run(loop, UV_RUN_DEFAULT)); - ASSERT_EQ(1, timer_cb_called); + ASSERT(0 == uv_timer_init(loop, &ci.timer_handle)); + ASSERT(0 == uv_timer_start(&ci.timer_handle, timer_cb, 10, 0)); + ASSERT(0 == uv_run(loop, UV_RUN_DEFAULT)); + ASSERT(1 == timer_cb_called); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -272,19 +236,19 @@ TEST_IMPL(threadpool_cancel_random) { saturate_threadpool(); loop = uv_default_loop(); - ASSERT_OK(uv_random(loop, - &req.random_req, - &req.buf, - sizeof(req.buf), - 0, - nop_random_cb)); - ASSERT_OK(uv_cancel((uv_req_t*) &req)); - ASSERT_OK(done_cb_called); + ASSERT(0 == uv_random(loop, + &req.random_req, + &req.buf, + sizeof(req.buf), + 0, + nop_random_cb)); + ASSERT(0 == uv_cancel((uv_req_t*) &req)); + ASSERT(0 == done_cb_called); unblock_threadpool(); - ASSERT_OK(uv_run(loop, UV_RUN_DEFAULT)); - ASSERT_EQ(1, done_cb_called); + ASSERT(0 == uv_run(loop, UV_RUN_DEFAULT)); + ASSERT(1 == done_cb_called); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -300,15 +264,15 @@ TEST_IMPL(threadpool_cancel_work) { saturate_threadpool(); for (i = 0; i < ARRAY_SIZE(reqs); i++) - ASSERT_OK(uv_queue_work(loop, reqs + i, work2_cb, done2_cb)); + ASSERT(0 == uv_queue_work(loop, reqs + i, work2_cb, done2_cb)); - ASSERT_OK(uv_timer_init(loop, &ci.timer_handle)); - ASSERT_OK(uv_timer_start(&ci.timer_handle, timer_cb, 10, 0)); - ASSERT_OK(uv_run(loop, UV_RUN_DEFAULT)); - ASSERT_EQ(1, timer_cb_called); - ASSERT_EQ(ARRAY_SIZE(reqs), done2_cb_called); + ASSERT(0 == uv_timer_init(loop, &ci.timer_handle)); + ASSERT(0 == uv_timer_start(&ci.timer_handle, timer_cb, 10, 0)); + ASSERT(0 == uv_run(loop, UV_RUN_DEFAULT)); + ASSERT(1 == timer_cb_called); + ASSERT(ARRAY_SIZE(reqs) == done2_cb_called); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -327,42 +291,42 @@ TEST_IMPL(threadpool_cancel_fs) { /* Needs to match ARRAY_SIZE(fs_reqs). */ n = 0; - ASSERT_OK(uv_fs_chmod(loop, reqs + n++, "/", 0, fs_cb)); - ASSERT_OK(uv_fs_chown(loop, reqs + n++, "/", 0, 0, fs_cb)); - ASSERT_OK(uv_fs_close(loop, reqs + n++, 0, fs_cb)); - ASSERT_OK(uv_fs_fchmod(loop, reqs + n++, 0, 0, fs_cb)); - ASSERT_OK(uv_fs_fchown(loop, reqs + n++, 0, 0, 0, fs_cb)); - ASSERT_OK(uv_fs_fdatasync(loop, reqs + n++, 0, fs_cb)); - ASSERT_OK(uv_fs_fstat(loop, reqs + n++, 0, fs_cb)); - ASSERT_OK(uv_fs_fsync(loop, reqs + n++, 0, fs_cb)); - ASSERT_OK(uv_fs_ftruncate(loop, reqs + n++, 0, 0, fs_cb)); - ASSERT_OK(uv_fs_futime(loop, reqs + n++, 0, 0, 0, fs_cb)); - ASSERT_OK(uv_fs_link(loop, reqs + n++, "/", "/", fs_cb)); - ASSERT_OK(uv_fs_lstat(loop, reqs + n++, "/", fs_cb)); - ASSERT_OK(uv_fs_mkdir(loop, reqs + n++, "/", 0, fs_cb)); - ASSERT_OK(uv_fs_open(loop, reqs + n++, "/", 0, 0, fs_cb)); - ASSERT_OK(uv_fs_read(loop, reqs + n++, -1, &iov, 1, 0, fs_cb)); - ASSERT_OK(uv_fs_scandir(loop, reqs + n++, "/", 0, fs_cb)); - ASSERT_OK(uv_fs_readlink(loop, reqs + n++, "/", fs_cb)); - ASSERT_OK(uv_fs_realpath(loop, reqs + n++, "/", fs_cb)); - ASSERT_OK(uv_fs_rename(loop, reqs + n++, "/", "/", fs_cb)); - ASSERT_OK(uv_fs_mkdir(loop, reqs + n++, "/", 0, fs_cb)); - ASSERT_OK(uv_fs_sendfile(loop, reqs + n++, 0, 0, 0, 0, fs_cb)); - ASSERT_OK(uv_fs_stat(loop, reqs + n++, "/", fs_cb)); - ASSERT_OK(uv_fs_symlink(loop, reqs + n++, "/", "/", 0, fs_cb)); - ASSERT_OK(uv_fs_unlink(loop, reqs + n++, "/", fs_cb)); - ASSERT_OK(uv_fs_utime(loop, reqs + n++, "/", 0, 0, fs_cb)); - ASSERT_OK(uv_fs_write(loop, reqs + n++, -1, &iov, 1, 0, fs_cb)); - ASSERT_EQ(n, ARRAY_SIZE(reqs)); - - ASSERT_OK(uv_timer_init(loop, &ci.timer_handle)); - ASSERT_OK(uv_timer_start(&ci.timer_handle, timer_cb, 10, 0)); - ASSERT_OK(uv_run(loop, UV_RUN_DEFAULT)); - ASSERT_EQ(n, fs_cb_called); - ASSERT_EQ(1, timer_cb_called); - - - MAKE_VALGRIND_HAPPY(loop); + ASSERT(0 == uv_fs_chmod(loop, reqs + n++, "/", 0, fs_cb)); + ASSERT(0 == uv_fs_chown(loop, reqs + n++, "/", 0, 0, fs_cb)); + ASSERT(0 == uv_fs_close(loop, reqs + n++, 0, fs_cb)); + ASSERT(0 == uv_fs_fchmod(loop, reqs + n++, 0, 0, fs_cb)); + ASSERT(0 == uv_fs_fchown(loop, reqs + n++, 0, 0, 0, fs_cb)); + ASSERT(0 == uv_fs_fdatasync(loop, reqs + n++, 0, fs_cb)); + ASSERT(0 == uv_fs_fstat(loop, reqs + n++, 0, fs_cb)); + ASSERT(0 == uv_fs_fsync(loop, reqs + n++, 0, fs_cb)); + ASSERT(0 == uv_fs_ftruncate(loop, reqs + n++, 0, 0, fs_cb)); + ASSERT(0 == uv_fs_futime(loop, reqs + n++, 0, 0, 0, fs_cb)); + ASSERT(0 == uv_fs_link(loop, reqs + n++, "/", "/", fs_cb)); + ASSERT(0 == uv_fs_lstat(loop, reqs + n++, "/", fs_cb)); + ASSERT(0 == uv_fs_mkdir(loop, reqs + n++, "/", 0, fs_cb)); + ASSERT(0 == uv_fs_open(loop, reqs + n++, "/", 0, 0, fs_cb)); + ASSERT(0 == uv_fs_read(loop, reqs + n++, 0, &iov, 1, 0, fs_cb)); + ASSERT(0 == uv_fs_scandir(loop, reqs + n++, "/", 0, fs_cb)); + ASSERT(0 == uv_fs_readlink(loop, reqs + n++, "/", fs_cb)); + ASSERT(0 == uv_fs_realpath(loop, reqs + n++, "/", fs_cb)); + ASSERT(0 == uv_fs_rename(loop, reqs + n++, "/", "/", fs_cb)); + ASSERT(0 == uv_fs_mkdir(loop, reqs + n++, "/", 0, fs_cb)); + ASSERT(0 == uv_fs_sendfile(loop, reqs + n++, 0, 0, 0, 0, fs_cb)); + ASSERT(0 == uv_fs_stat(loop, reqs + n++, "/", fs_cb)); + ASSERT(0 == uv_fs_symlink(loop, reqs + n++, "/", "/", 0, fs_cb)); + ASSERT(0 == uv_fs_unlink(loop, reqs + n++, "/", fs_cb)); + ASSERT(0 == uv_fs_utime(loop, reqs + n++, "/", 0, 0, fs_cb)); + ASSERT(0 == uv_fs_write(loop, reqs + n++, 0, &iov, 1, 0, fs_cb)); + ASSERT(n == ARRAY_SIZE(reqs)); + + ASSERT(0 == uv_timer_init(loop, &ci.timer_handle)); + ASSERT(0 == uv_timer_start(&ci.timer_handle, timer_cb, 10, 0)); + ASSERT(0 == uv_run(loop, UV_RUN_DEFAULT)); + ASSERT(n == fs_cb_called); + ASSERT(1 == timer_cb_called); + + + MAKE_VALGRIND_HAPPY(); return 0; } @@ -373,46 +337,13 @@ TEST_IMPL(threadpool_cancel_single) { saturate_threadpool(); loop = uv_default_loop(); - ASSERT_OK(uv_queue_work(loop, &req, (uv_work_cb) abort, nop_done_cb)); - ASSERT_OK(uv_cancel((uv_req_t*) &req)); - ASSERT_OK(done_cb_called); + ASSERT(0 == uv_queue_work(loop, &req, (uv_work_cb) abort, nop_done_cb)); + ASSERT(0 == uv_cancel((uv_req_t*) &req)); + ASSERT(0 == done_cb_called); unblock_threadpool(); - ASSERT_OK(uv_run(loop, UV_RUN_DEFAULT)); - ASSERT_EQ(1, done_cb_called); - - MAKE_VALGRIND_HAPPY(loop); - return 0; -} - - -static void after_busy_cb(uv_work_t* req, int status) { - ASSERT_OK(status); - done_cb_called++; -} - -static void busy_cb(uv_work_t* req) { - uv_sem_post((uv_sem_t*) req->data); - /* Assume that calling uv_cancel() takes less than 10ms. */ - uv_sleep(10); -} - -TEST_IMPL(threadpool_cancel_when_busy) { - uv_sem_t sem_lock; - uv_work_t req; - - req.data = &sem_lock; - - ASSERT_OK(uv_sem_init(&sem_lock, 0)); - ASSERT_OK(uv_queue_work(uv_default_loop(), &req, busy_cb, after_busy_cb)); - - uv_sem_wait(&sem_lock); - - ASSERT_EQ(uv_cancel((uv_req_t*) &req), UV_EBUSY); - ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT)); - ASSERT_EQ(1, done_cb_called); - - uv_sem_destroy(&sem_lock); + ASSERT(0 == uv_run(loop, UV_RUN_DEFAULT)); + ASSERT(1 == done_cb_called); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-threadpool.c b/test/test-threadpool.c index fb5e573..e3d17d7 100644 --- a/test/test-threadpool.c +++ b/test/test-threadpool.c @@ -29,16 +29,16 @@ static char data; static void work_cb(uv_work_t* req) { - ASSERT_PTR_EQ(req, &work_req); - ASSERT_PTR_EQ(req->data, &data); + ASSERT(req == &work_req); + ASSERT(req->data == &data); work_cb_count++; } static void after_work_cb(uv_work_t* req, int status) { - ASSERT_OK(status); - ASSERT_PTR_EQ(req, &work_req); - ASSERT_PTR_EQ(req->data, &data); + ASSERT(status == 0); + ASSERT(req == &work_req); + ASSERT(req->data == &data); after_work_cb_count++; } @@ -48,13 +48,13 @@ TEST_IMPL(threadpool_queue_work_simple) { work_req.data = &data; r = uv_queue_work(uv_default_loop(), &work_req, work_cb, after_work_cb); - ASSERT_OK(r); + ASSERT(r == 0); uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_EQ(1, work_cb_count); - ASSERT_EQ(1, after_work_cb_count); + ASSERT(work_cb_count == 1); + ASSERT(after_work_cb_count == 1); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -64,13 +64,13 @@ TEST_IMPL(threadpool_queue_work_einval) { work_req.data = &data; r = uv_queue_work(uv_default_loop(), &work_req, NULL, after_work_cb); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_OK(work_cb_count); - ASSERT_OK(after_work_cb_count); + ASSERT(work_cb_count == 0); + ASSERT(after_work_cb_count == 0); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-timer-again.c b/test/test-timer-again.c index d7f0b83..834b59d 100644 --- a/test/test-timer-again.c +++ b/test/test-timer-again.c @@ -44,8 +44,8 @@ static void close_cb(uv_handle_t* handle) { static void repeat_1_cb(uv_timer_t* handle) { int r; - ASSERT_PTR_EQ(handle, &repeat_1); - ASSERT_EQ(50, uv_timer_get_repeat((uv_timer_t*)handle)); + ASSERT(handle == &repeat_1); + ASSERT(uv_timer_get_repeat((uv_timer_t*)handle) == 50); fprintf(stderr, "repeat_1_cb called after %ld ms\n", (long int)(uv_now(uv_default_loop()) - start_time)); @@ -54,7 +54,7 @@ static void repeat_1_cb(uv_timer_t* handle) { repeat_1_cb_called++; r = uv_timer_again(&repeat_2); - ASSERT_OK(r); + ASSERT(r == 0); if (repeat_1_cb_called == 10) { uv_close((uv_handle_t*)handle, close_cb); @@ -67,7 +67,7 @@ static void repeat_1_cb(uv_timer_t* handle) { static void repeat_2_cb(uv_timer_t* handle) { - ASSERT_PTR_EQ(handle, &repeat_2); + ASSERT(handle == &repeat_2); ASSERT(repeat_2_cb_allowed); fprintf(stderr, "repeat_2_cb called after %ld ms\n", @@ -77,7 +77,7 @@ static void repeat_2_cb(uv_timer_t* handle) { repeat_2_cb_called++; if (uv_timer_get_repeat(&repeat_2) == 0) { - ASSERT_OK(uv_is_active((uv_handle_t*) handle)); + ASSERT(0 == uv_is_active((uv_handle_t*) handle)); uv_close((uv_handle_t*)handle, close_cb); return; } @@ -85,7 +85,7 @@ static void repeat_2_cb(uv_timer_t* handle) { fprintf(stderr, "uv_timer_get_repeat %ld ms\n", (long int)uv_timer_get_repeat(&repeat_2)); fflush(stderr); - ASSERT_EQ(100, uv_timer_get_repeat(&repeat_2)); + ASSERT(uv_timer_get_repeat(&repeat_2) == 100); /* This shouldn't take effect immediately. */ uv_timer_set_repeat(&repeat_2, 0); @@ -96,46 +96,46 @@ TEST_IMPL(timer_again) { int r; start_time = uv_now(uv_default_loop()); - ASSERT_LT(0, start_time); + ASSERT(0 < start_time); /* Verify that it is not possible to uv_timer_again a never-started timer. */ r = uv_timer_init(uv_default_loop(), &dummy); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_timer_again(&dummy); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); uv_unref((uv_handle_t*)&dummy); /* Start timer repeat_1. */ r = uv_timer_init(uv_default_loop(), &repeat_1); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_timer_start(&repeat_1, repeat_1_cb, 50, 0); - ASSERT_OK(r); - ASSERT_OK(uv_timer_get_repeat(&repeat_1)); + ASSERT(r == 0); + ASSERT(uv_timer_get_repeat(&repeat_1) == 0); /* Actually make repeat_1 repeating. */ uv_timer_set_repeat(&repeat_1, 50); - ASSERT_EQ(50, uv_timer_get_repeat(&repeat_1)); + ASSERT(uv_timer_get_repeat(&repeat_1) == 50); /* * Start another repeating timer. It'll be again()ed by the repeat_1 so * it should not time out until repeat_1 stops. */ r = uv_timer_init(uv_default_loop(), &repeat_2); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_timer_start(&repeat_2, repeat_2_cb, 100, 100); - ASSERT_OK(r); - ASSERT_EQ(100, uv_timer_get_repeat(&repeat_2)); + ASSERT(r == 0); + ASSERT(uv_timer_get_repeat(&repeat_2) == 100); uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_EQ(10, repeat_1_cb_called); - ASSERT_EQ(2, repeat_2_cb_called); - ASSERT_EQ(2, close_cb_called); + ASSERT(repeat_1_cb_called == 10); + ASSERT(repeat_2_cb_called == 2); + ASSERT(close_cb_called == 2); fprintf(stderr, "Test took %ld ms (expected ~700 ms)\n", (long int)(uv_now(uv_default_loop()) - start_time)); fflush(stderr); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-timer-from-check.c b/test/test-timer-from-check.c index e5f5cb2..a18c7e1 100644 --- a/test/test-timer-from-check.c +++ b/test/test-timer-from-check.c @@ -32,49 +32,49 @@ static int timer_cb_called; static void prepare_cb(uv_prepare_t* handle) { - ASSERT_OK(uv_prepare_stop(&prepare_handle)); - ASSERT_OK(prepare_cb_called); - ASSERT_EQ(1, check_cb_called); - ASSERT_OK(timer_cb_called); + ASSERT(0 == uv_prepare_stop(&prepare_handle)); + ASSERT(0 == prepare_cb_called); + ASSERT(1 == check_cb_called); + ASSERT(0 == timer_cb_called); prepare_cb_called++; } static void timer_cb(uv_timer_t* handle) { - ASSERT_OK(uv_timer_stop(&timer_handle)); - ASSERT_EQ(1, prepare_cb_called); - ASSERT_EQ(1, check_cb_called); - ASSERT_OK(timer_cb_called); + ASSERT(0 == uv_timer_stop(&timer_handle)); + ASSERT(1 == prepare_cb_called); + ASSERT(1 == check_cb_called); + ASSERT(0 == timer_cb_called); timer_cb_called++; } static void check_cb(uv_check_t* handle) { - ASSERT_OK(uv_check_stop(&check_handle)); - ASSERT_OK(uv_timer_stop(&timer_handle)); /* Runs before timer_cb. */ - ASSERT_OK(uv_timer_start(&timer_handle, timer_cb, 50, 0)); - ASSERT_OK(uv_prepare_start(&prepare_handle, prepare_cb)); - ASSERT_OK(prepare_cb_called); - ASSERT_OK(check_cb_called); - ASSERT_OK(timer_cb_called); + ASSERT(0 == uv_check_stop(&check_handle)); + ASSERT(0 == uv_timer_stop(&timer_handle)); /* Runs before timer_cb. */ + ASSERT(0 == uv_timer_start(&timer_handle, timer_cb, 50, 0)); + ASSERT(0 == uv_prepare_start(&prepare_handle, prepare_cb)); + ASSERT(0 == prepare_cb_called); + ASSERT(0 == check_cb_called); + ASSERT(0 == timer_cb_called); check_cb_called++; } TEST_IMPL(timer_from_check) { - ASSERT_OK(uv_prepare_init(uv_default_loop(), &prepare_handle)); - ASSERT_OK(uv_check_init(uv_default_loop(), &check_handle)); - ASSERT_OK(uv_check_start(&check_handle, check_cb)); - ASSERT_OK(uv_timer_init(uv_default_loop(), &timer_handle)); - ASSERT_OK(uv_timer_start(&timer_handle, timer_cb, 50, 0)); - ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT)); - ASSERT_EQ(1, prepare_cb_called); - ASSERT_EQ(1, check_cb_called); - ASSERT_EQ(1, timer_cb_called); + ASSERT(0 == uv_prepare_init(uv_default_loop(), &prepare_handle)); + ASSERT(0 == uv_check_init(uv_default_loop(), &check_handle)); + ASSERT(0 == uv_check_start(&check_handle, check_cb)); + ASSERT(0 == uv_timer_init(uv_default_loop(), &timer_handle)); + ASSERT(0 == uv_timer_start(&timer_handle, timer_cb, 50, 0)); + ASSERT(0 == uv_run(uv_default_loop(), UV_RUN_DEFAULT)); + ASSERT(1 == prepare_cb_called); + ASSERT(1 == check_cb_called); + ASSERT(1 == timer_cb_called); uv_close((uv_handle_t*) &prepare_handle, NULL); uv_close((uv_handle_t*) &check_handle, NULL); uv_close((uv_handle_t*) &timer_handle, NULL); - ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_ONCE)); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + ASSERT(0 == uv_run(uv_default_loop(), UV_RUN_ONCE)); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-timer.c b/test/test-timer.c index 641d3a9..a9fa534 100644 --- a/test/test-timer.c +++ b/test/test-timer.c @@ -30,8 +30,6 @@ static int twice_close_cb_called = 0; static int repeat_cb_called = 0; static int repeat_close_cb_called = 0; static int order_cb_called = 0; -static int timer_check_double_call_called = 0; -static int zero_timeout_cb_calls = 0; static uint64_t start_time; static uv_timer_t tiny_timer; static uv_timer_t huge_timer1; @@ -42,7 +40,7 @@ static void once_close_cb(uv_handle_t* handle) { printf("ONCE_CLOSE_CB\n"); ASSERT_NOT_NULL(handle); - ASSERT_OK(uv_is_active(handle)); + ASSERT(0 == uv_is_active(handle)); once_close_cb_called++; } @@ -52,7 +50,7 @@ static void once_cb(uv_timer_t* handle) { printf("ONCE_CB %d\n", once_cb_called); ASSERT_NOT_NULL(handle); - ASSERT_OK(uv_is_active((uv_handle_t*) handle)); + ASSERT(0 == uv_is_active((uv_handle_t*) handle)); once_cb_called++; @@ -66,7 +64,7 @@ static void twice_close_cb(uv_handle_t* handle) { printf("TWICE_CLOSE_CB\n"); ASSERT_NOT_NULL(handle); - ASSERT_OK(uv_is_active(handle)); + ASSERT(0 == uv_is_active(handle)); twice_close_cb_called++; } @@ -75,7 +73,7 @@ static void twice_cb(uv_timer_t* handle) { printf("TWICE_CB %d\n", twice_cb_called); ASSERT_NOT_NULL(handle); - ASSERT_OK(uv_is_active((uv_handle_t*) handle)); + ASSERT(0 == uv_is_active((uv_handle_t*) handle)); twice_cb_called++; @@ -97,7 +95,7 @@ static void repeat_cb(uv_timer_t* handle) { printf("REPEAT_CB\n"); ASSERT_NOT_NULL(handle); - ASSERT_EQ(1, uv_is_active((uv_handle_t*) handle)); + ASSERT(1 == uv_is_active((uv_handle_t*) handle)); repeat_cb_called++; @@ -120,43 +118,43 @@ TEST_IMPL(timer) { int r; start_time = uv_now(uv_default_loop()); - ASSERT_LT(0, start_time); + ASSERT(0 < start_time); /* Let 10 timers time out in 500 ms total. */ for (i = 0; i < ARRAY_SIZE(once_timers); i++) { once = once_timers + i; r = uv_timer_init(uv_default_loop(), once); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_timer_start(once, once_cb, i * 50, 0); - ASSERT_OK(r); + ASSERT(r == 0); } /* The 11th timer is a repeating timer that runs 4 times */ r = uv_timer_init(uv_default_loop(), &repeat); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_timer_start(&repeat, repeat_cb, 100, 100); - ASSERT_OK(r); + ASSERT(r == 0); /* The 12th timer should not do anything. */ r = uv_timer_init(uv_default_loop(), &never); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_timer_start(&never, never_cb, 100, 100); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_timer_stop(&never); - ASSERT_OK(r); + ASSERT(r == 0); uv_unref((uv_handle_t*)&never); uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_EQ(10, once_cb_called); - ASSERT_EQ(10, once_close_cb_called); + ASSERT(once_cb_called == 10); + ASSERT(once_close_cb_called == 10); printf("repeat_cb_called %d\n", repeat_cb_called); - ASSERT_EQ(5, repeat_cb_called); - ASSERT_EQ(1, repeat_close_cb_called); + ASSERT(repeat_cb_called == 5); + ASSERT(repeat_close_cb_called == 1); - ASSERT_LE(500, uv_now(uv_default_loop()) - start_time); + ASSERT(500 <= uv_now(uv_default_loop()) - start_time); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -166,17 +164,17 @@ TEST_IMPL(timer_start_twice) { int r; r = uv_timer_init(uv_default_loop(), &once); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_timer_start(&once, never_cb, 86400 * 1000, 0); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_timer_start(&once, twice_cb, 10, 0); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_EQ(1, twice_cb_called); + ASSERT(twice_cb_called == 1); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -184,23 +182,23 @@ TEST_IMPL(timer_start_twice) { TEST_IMPL(timer_init) { uv_timer_t handle; - ASSERT_OK(uv_timer_init(uv_default_loop(), &handle)); - ASSERT_OK(uv_timer_get_repeat(&handle)); + ASSERT(0 == uv_timer_init(uv_default_loop(), &handle)); + ASSERT(0 == uv_timer_get_repeat(&handle)); ASSERT_UINT64_LE(0, uv_timer_get_due_in(&handle)); - ASSERT_OK(uv_is_active((uv_handle_t*) &handle)); + ASSERT(0 == uv_is_active((uv_handle_t*) &handle)); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } static void order_cb_a(uv_timer_t *handle) { - ASSERT_EQ(order_cb_called++, *(int*)handle->data); + ASSERT(order_cb_called++ == *(int*)handle->data); } static void order_cb_b(uv_timer_t *handle) { - ASSERT_EQ(order_cb_called++, *(int*)handle->data); + ASSERT(order_cb_called++ == *(int*)handle->data); } @@ -212,64 +210,39 @@ TEST_IMPL(timer_order) { first = 0; second = 1; - ASSERT_OK(uv_timer_init(uv_default_loop(), &handle_a)); - ASSERT_OK(uv_timer_init(uv_default_loop(), &handle_b)); + ASSERT(0 == uv_timer_init(uv_default_loop(), &handle_a)); + ASSERT(0 == uv_timer_init(uv_default_loop(), &handle_b)); /* Test for starting handle_a then handle_b */ handle_a.data = &first; - ASSERT_OK(uv_timer_start(&handle_a, order_cb_a, 0, 0)); + ASSERT(0 == uv_timer_start(&handle_a, order_cb_a, 0, 0)); handle_b.data = &second; - ASSERT_OK(uv_timer_start(&handle_b, order_cb_b, 0, 0)); - ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT)); + ASSERT(0 == uv_timer_start(&handle_b, order_cb_b, 0, 0)); + ASSERT(0 == uv_run(uv_default_loop(), UV_RUN_DEFAULT)); - ASSERT_EQ(2, order_cb_called); + ASSERT(order_cb_called == 2); - ASSERT_OK(uv_timer_stop(&handle_a)); - ASSERT_OK(uv_timer_stop(&handle_b)); + ASSERT(0 == uv_timer_stop(&handle_a)); + ASSERT(0 == uv_timer_stop(&handle_b)); /* Test for starting handle_b then handle_a */ order_cb_called = 0; handle_b.data = &first; - ASSERT_OK(uv_timer_start(&handle_b, order_cb_b, 0, 0)); + ASSERT(0 == uv_timer_start(&handle_b, order_cb_b, 0, 0)); handle_a.data = &second; - ASSERT_OK(uv_timer_start(&handle_a, order_cb_a, 0, 0)); - ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT)); + ASSERT(0 == uv_timer_start(&handle_a, order_cb_a, 0, 0)); + ASSERT(0 == uv_run(uv_default_loop(), UV_RUN_DEFAULT)); - ASSERT_EQ(2, order_cb_called); + ASSERT(order_cb_called == 2); - MAKE_VALGRIND_HAPPY(uv_default_loop()); - return 0; -} - - -static void zero_timeout_cb(uv_timer_t* handle) { - ASSERT_OK(uv_timer_start(handle, zero_timeout_cb, 0, 0)); - uv_stop(handle->loop); - zero_timeout_cb_calls++; -} - - -TEST_IMPL(timer_zero_timeout) { - uv_timer_t timer; - uv_loop_t* loop; - - loop = uv_default_loop(); - ASSERT_OK(uv_timer_init(loop, &timer)); - ASSERT_OK(uv_timer_start(&timer, zero_timeout_cb, 0, 0)); - ASSERT_EQ(1, uv_run(loop, UV_RUN_DEFAULT)); /* because of uv_stop() */ - ASSERT_EQ(1, zero_timeout_cb_calls); - uv_close((uv_handle_t*) &timer, NULL); - ASSERT_OK(uv_run(loop, UV_RUN_DEFAULT)); - ASSERT_EQ(1, zero_timeout_cb_calls); - - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } static void tiny_timer_cb(uv_timer_t* handle) { - ASSERT_PTR_EQ(handle, &tiny_timer); + ASSERT(handle == &tiny_timer); uv_close((uv_handle_t*) &tiny_timer, NULL); uv_close((uv_handle_t*) &huge_timer1, NULL); uv_close((uv_handle_t*) &huge_timer2, NULL); @@ -277,20 +250,17 @@ static void tiny_timer_cb(uv_timer_t* handle) { TEST_IMPL(timer_huge_timeout) { - ASSERT_OK(uv_timer_init(uv_default_loop(), &tiny_timer)); - ASSERT_OK(uv_timer_init(uv_default_loop(), &huge_timer1)); - ASSERT_OK(uv_timer_init(uv_default_loop(), &huge_timer2)); - ASSERT_OK(uv_timer_start(&tiny_timer, tiny_timer_cb, 1, 0)); - ASSERT_OK(uv_timer_start(&huge_timer1, - tiny_timer_cb, - 0xffffffffffffLL, - 0)); - ASSERT_OK(uv_timer_start(&huge_timer2, tiny_timer_cb, (uint64_t) -1, 0)); + ASSERT(0 == uv_timer_init(uv_default_loop(), &tiny_timer)); + ASSERT(0 == uv_timer_init(uv_default_loop(), &huge_timer1)); + ASSERT(0 == uv_timer_init(uv_default_loop(), &huge_timer2)); + ASSERT(0 == uv_timer_start(&tiny_timer, tiny_timer_cb, 1, 0)); + ASSERT(0 == uv_timer_start(&huge_timer1, tiny_timer_cb, 0xffffffffffffLL, 0)); + ASSERT(0 == uv_timer_start(&huge_timer2, tiny_timer_cb, (uint64_t) -1, 0)); ASSERT_UINT64_EQ(1, uv_timer_get_due_in(&tiny_timer)); ASSERT_UINT64_EQ(281474976710655, uv_timer_get_due_in(&huge_timer1)); ASSERT_UINT64_LE(0, uv_timer_get_due_in(&huge_timer2)); - ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT)); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + ASSERT(0 == uv_run(uv_default_loop(), UV_RUN_DEFAULT)); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -299,9 +269,9 @@ static void huge_repeat_cb(uv_timer_t* handle) { static int ncalls; if (ncalls == 0) - ASSERT_PTR_EQ(handle, &huge_timer1); + ASSERT(handle == &huge_timer1); else - ASSERT_PTR_EQ(handle, &tiny_timer); + ASSERT(handle == &tiny_timer); if (++ncalls == 10) { uv_close((uv_handle_t*) &tiny_timer, NULL); @@ -311,12 +281,12 @@ static void huge_repeat_cb(uv_timer_t* handle) { TEST_IMPL(timer_huge_repeat) { - ASSERT_OK(uv_timer_init(uv_default_loop(), &tiny_timer)); - ASSERT_OK(uv_timer_init(uv_default_loop(), &huge_timer1)); - ASSERT_OK(uv_timer_start(&tiny_timer, huge_repeat_cb, 2, 2)); - ASSERT_OK(uv_timer_start(&huge_timer1, huge_repeat_cb, 1, (uint64_t) -1)); - ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT)); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + ASSERT(0 == uv_timer_init(uv_default_loop(), &tiny_timer)); + ASSERT(0 == uv_timer_init(uv_default_loop(), &huge_timer1)); + ASSERT(0 == uv_timer_start(&tiny_timer, huge_repeat_cb, 2, 2)); + ASSERT(0 == uv_timer_start(&huge_timer1, huge_repeat_cb, 1, (uint64_t) -1)); + ASSERT(0 == uv_run(uv_default_loop(), UV_RUN_DEFAULT)); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -332,19 +302,19 @@ static void timer_run_once_timer_cb(uv_timer_t* handle) { TEST_IMPL(timer_run_once) { uv_timer_t timer_handle; - ASSERT_OK(uv_timer_init(uv_default_loop(), &timer_handle)); - ASSERT_OK(uv_timer_start(&timer_handle, timer_run_once_timer_cb, 0, 0)); - ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_ONCE)); - ASSERT_EQ(1, timer_run_once_timer_cb_called); + ASSERT(0 == uv_timer_init(uv_default_loop(), &timer_handle)); + ASSERT(0 == uv_timer_start(&timer_handle, timer_run_once_timer_cb, 0, 0)); + ASSERT(0 == uv_run(uv_default_loop(), UV_RUN_ONCE)); + ASSERT(1 == timer_run_once_timer_cb_called); - ASSERT_OK(uv_timer_start(&timer_handle, timer_run_once_timer_cb, 1, 0)); - ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_ONCE)); - ASSERT_EQ(2, timer_run_once_timer_cb_called); + ASSERT(0 == uv_timer_start(&timer_handle, timer_run_once_timer_cb, 1, 0)); + ASSERT(0 == uv_run(uv_default_loop(), UV_RUN_ONCE)); + ASSERT(2 == timer_run_once_timer_cb_called); uv_close((uv_handle_t*) &timer_handle, NULL); - ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_ONCE)); + ASSERT(0 == uv_run(uv_default_loop(), UV_RUN_ONCE)); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -352,12 +322,12 @@ TEST_IMPL(timer_run_once) { TEST_IMPL(timer_is_closing) { uv_timer_t handle; - ASSERT_OK(uv_timer_init(uv_default_loop(), &handle)); + ASSERT(0 == uv_timer_init(uv_default_loop(), &handle)); uv_close((uv_handle_t *)&handle, NULL); - ASSERT_EQ(UV_EINVAL, uv_timer_start(&handle, never_cb, 100, 100)); + ASSERT(UV_EINVAL == uv_timer_start(&handle, never_cb, 100, 100)); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -365,10 +335,10 @@ TEST_IMPL(timer_is_closing) { TEST_IMPL(timer_null_callback) { uv_timer_t handle; - ASSERT_OK(uv_timer_init(uv_default_loop(), &handle)); - ASSERT_EQ(UV_EINVAL, uv_timer_start(&handle, NULL, 100, 100)); + ASSERT(0 == uv_timer_init(uv_default_loop(), &handle)); + ASSERT(UV_EINVAL == uv_timer_start(&handle, NULL, 100, 100)); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -378,7 +348,7 @@ static uint64_t timer_early_check_expected_time; static void timer_early_check_cb(uv_timer_t* handle) { uint64_t hrtime = uv_hrtime() / 1000000; - ASSERT_GE(hrtime, timer_early_check_expected_time); + ASSERT(hrtime >= timer_early_check_expected_time); } @@ -388,66 +358,13 @@ TEST_IMPL(timer_early_check) { timer_early_check_expected_time = uv_now(uv_default_loop()) + timeout_ms; - ASSERT_OK(uv_timer_init(uv_default_loop(), &timer_handle)); - ASSERT_OK(uv_timer_start(&timer_handle, - timer_early_check_cb, - timeout_ms, - 0)); - ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT)); + ASSERT(0 == uv_timer_init(uv_default_loop(), &timer_handle)); + ASSERT(0 == uv_timer_start(&timer_handle, timer_early_check_cb, timeout_ms, 0)); + ASSERT(0 == uv_run(uv_default_loop(), UV_RUN_DEFAULT)); uv_close((uv_handle_t*) &timer_handle, NULL); - ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT)); - - MAKE_VALGRIND_HAPPY(uv_default_loop()); - return 0; -} - -static void timer_check_double_call(uv_timer_t* handle) { - timer_check_double_call_called++; -} - -TEST_IMPL(timer_no_double_call_once) { - uv_timer_t timer_handle; - const uint64_t timeout_ms = 10; - - ASSERT_OK(uv_timer_init(uv_default_loop(), &timer_handle)); - ASSERT_OK(uv_timer_start(&timer_handle, - timer_check_double_call, - timeout_ms, - timeout_ms)); - uv_sleep(timeout_ms * 2); - ASSERT_EQ(1, uv_run(uv_default_loop(), UV_RUN_ONCE)); - ASSERT_EQ(1, timer_check_double_call_called); - - MAKE_VALGRIND_HAPPY(uv_default_loop()); - return 0; -} - -TEST_IMPL(timer_no_double_call_nowait) { - uv_timer_t timer_handle; - const uint64_t timeout_ms = 10; - - ASSERT_OK(uv_timer_init(uv_default_loop(), &timer_handle)); - ASSERT_OK(uv_timer_start(&timer_handle, - timer_check_double_call, - timeout_ms, - timeout_ms)); - uv_sleep(timeout_ms * 2); - ASSERT_EQ(1, uv_run(uv_default_loop(), UV_RUN_NOWAIT)); - ASSERT_EQ(1, timer_check_double_call_called); - - MAKE_VALGRIND_HAPPY(uv_default_loop()); - return 0; -} - -TEST_IMPL(timer_no_run_on_unref) { - uv_timer_t timer_handle; - - ASSERT_OK(uv_timer_init(uv_default_loop(), &timer_handle)); - ASSERT_OK(uv_timer_start(&timer_handle, (uv_timer_cb) abort, 0, 0)); - uv_unref((uv_handle_t*) &timer_handle); - ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT)); + ASSERT(0 == uv_run(uv_default_loop(), UV_RUN_DEFAULT)); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-tmpdir.c b/test/test-tmpdir.c index a4e9ce9..86f72e2 100644 --- a/test/test-tmpdir.c +++ b/test/test-tmpdir.c @@ -36,46 +36,46 @@ TEST_IMPL(tmpdir) { len = sizeof tmpdir; tmpdir[0] = '\0'; - ASSERT_OK(strlen(tmpdir)); + ASSERT(strlen(tmpdir) == 0); r = uv_os_tmpdir(tmpdir, &len); - ASSERT_OK(r); - ASSERT_EQ(strlen(tmpdir), len); - ASSERT_GT(len, 0); - ASSERT_EQ(tmpdir[len], '\0'); + ASSERT(r == 0); + ASSERT(strlen(tmpdir) == len); + ASSERT(len > 0); + ASSERT(tmpdir[len] == '\0'); if (len > 1) { last = tmpdir[len - 1]; #ifdef _WIN32 - ASSERT_NE(last, '\\'); + ASSERT(last != '\\'); #else - ASSERT_NE(last, '/'); + ASSERT(last != '/'); #endif } /* Test the case where the buffer is too small */ len = SMALLPATH; r = uv_os_tmpdir(tmpdir, &len); - ASSERT_EQ(r, UV_ENOBUFS); - ASSERT_GT(len, SMALLPATH); + ASSERT(r == UV_ENOBUFS); + ASSERT(len > SMALLPATH); /* Test invalid inputs */ r = uv_os_tmpdir(NULL, &len); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); r = uv_os_tmpdir(tmpdir, NULL); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); len = 0; r = uv_os_tmpdir(tmpdir, &len); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); #ifdef _WIN32 const char *name = "TMP"; char tmpdir_win[] = "C:\\xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"; r = uv_os_setenv(name, tmpdir_win); - ASSERT_OK(r); + ASSERT(r == 0); char tmpdirx[PATHMAX]; size_t lenx = sizeof tmpdirx; r = uv_os_tmpdir(tmpdirx, &lenx); - ASSERT_OK(r); + ASSERT(r == 0); #endif return 0; diff --git a/test/test-tty-duplicate-key.c b/test/test-tty-duplicate-key.c index 871d580..efd79e1 100644 --- a/test/test-tty-duplicate-key.c +++ b/test/test-tty-duplicate-key.c @@ -73,7 +73,7 @@ static void tty_read(uv_stream_t* tty_in, ssize_t nread, const uv_buf_t* buf) { } uv_close((uv_handle_t*) tty_in, NULL); } else { - ASSERT_OK(nread); + ASSERT(nread == 0); } } @@ -150,25 +150,25 @@ TEST_IMPL(tty_duplicate_vt100_fn_key) { OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); - ASSERT_PTR_NE(handle, INVALID_HANDLE_VALUE); + ASSERT(handle != INVALID_HANDLE_VALUE); ttyin_fd = _open_osfhandle((intptr_t) handle, 0); - ASSERT_GE(ttyin_fd, 0); - ASSERT_EQ(UV_TTY, uv_guess_handle(ttyin_fd)); + ASSERT(ttyin_fd >= 0); + ASSERT(UV_TTY == uv_guess_handle(ttyin_fd)); r = uv_tty_init(uv_default_loop(), &tty_in, ttyin_fd, 1); /* Readable. */ - ASSERT_OK(r); + ASSERT(r == 0); ASSERT(uv_is_readable((uv_stream_t*) &tty_in)); ASSERT(!uv_is_writable((uv_stream_t*) &tty_in)); r = uv_read_start((uv_stream_t*)&tty_in, tty_alloc, tty_read); - ASSERT_OK(r); + ASSERT(r == 0); expect_str = ESC"[[A"; expect_nread = strlen(expect_str); /* Turn on raw mode. */ r = uv_tty_set_mode(&tty_in, UV_TTY_MODE_RAW); - ASSERT_OK(r); + ASSERT(r == 0); /* * Send F1 keystrokes. Test of issue cause by #2114 that vt100 fn key @@ -176,11 +176,11 @@ TEST_IMPL(tty_duplicate_vt100_fn_key) { */ make_key_event_records(VK_F1, 0, TRUE, records); WriteConsoleInputW(handle, records, ARRAY_SIZE(records), &written); - ASSERT_EQ(written, ARRAY_SIZE(records)); + ASSERT(written == ARRAY_SIZE(records)); uv_run(loop, UV_RUN_DEFAULT); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -204,49 +204,49 @@ TEST_IMPL(tty_duplicate_alt_modifier_key) { OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); - ASSERT_PTR_NE(handle, INVALID_HANDLE_VALUE); + ASSERT(handle != INVALID_HANDLE_VALUE); ttyin_fd = _open_osfhandle((intptr_t) handle, 0); - ASSERT_GE(ttyin_fd, 0); - ASSERT_EQ(UV_TTY, uv_guess_handle(ttyin_fd)); + ASSERT(ttyin_fd >= 0); + ASSERT(UV_TTY == uv_guess_handle(ttyin_fd)); r = uv_tty_init(uv_default_loop(), &tty_in, ttyin_fd, 1); /* Readable. */ - ASSERT_OK(r); + ASSERT(r == 0); ASSERT(uv_is_readable((uv_stream_t*) &tty_in)); ASSERT(!uv_is_writable((uv_stream_t*) &tty_in)); r = uv_read_start((uv_stream_t*)&tty_in, tty_alloc, tty_read); - ASSERT_OK(r); + ASSERT(r == 0); expect_str = ESC"a"ESC"a"; expect_nread = strlen(expect_str); /* Turn on raw mode. */ r = uv_tty_set_mode(&tty_in, UV_TTY_MODE_RAW); - ASSERT_OK(r); + ASSERT(r == 0); /* Emulate transmission of M-a at normal console */ make_key_event_records(VK_MENU, 0, TRUE, alt_records); WriteConsoleInputW(handle, &alt_records[0], 1, &written); - ASSERT_EQ(1, written); + ASSERT(written == 1); make_key_event_records(L'A', LEFT_ALT_PRESSED, FALSE, records); WriteConsoleInputW(handle, records, ARRAY_SIZE(records), &written); - ASSERT_EQ(2, written); + ASSERT(written == 2); WriteConsoleInputW(handle, &alt_records[1], 1, &written); - ASSERT_EQ(1, written); + ASSERT(written == 1); /* Emulate transmission of M-a at WSL(#2111) */ make_key_event_records(VK_MENU, 0, TRUE, alt_records); WriteConsoleInputW(handle, &alt_records[0], 1, &written); - ASSERT_EQ(1, written); + ASSERT(written == 1); make_key_event_records(L'A', LEFT_ALT_PRESSED, TRUE, records); WriteConsoleInputW(handle, records, ARRAY_SIZE(records), &written); - ASSERT_EQ(2, written); + ASSERT(written == 2); WriteConsoleInputW(handle, &alt_records[1], 1, &written); - ASSERT_EQ(1, written); + ASSERT(written == 1); uv_run(loop, UV_RUN_DEFAULT); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -270,25 +270,25 @@ TEST_IMPL(tty_composing_character) { OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); - ASSERT_PTR_NE(handle, INVALID_HANDLE_VALUE); + ASSERT(handle != INVALID_HANDLE_VALUE); ttyin_fd = _open_osfhandle((intptr_t) handle, 0); - ASSERT_GE(ttyin_fd, 0); - ASSERT_EQ(UV_TTY, uv_guess_handle(ttyin_fd)); + ASSERT(ttyin_fd >= 0); + ASSERT(UV_TTY == uv_guess_handle(ttyin_fd)); r = uv_tty_init(uv_default_loop(), &tty_in, ttyin_fd, 1); /* Readable. */ - ASSERT_OK(r); + ASSERT(r == 0); ASSERT(uv_is_readable((uv_stream_t*) &tty_in)); ASSERT(!uv_is_writable((uv_stream_t*) &tty_in)); r = uv_read_start((uv_stream_t*)&tty_in, tty_alloc, tty_read); - ASSERT_OK(r); + ASSERT(r == 0); expect_str = EUR_UTF8; expect_nread = strlen(expect_str); /* Turn on raw mode. */ r = uv_tty_set_mode(&tty_in, UV_TTY_MODE_RAW); - ASSERT_OK(r); + ASSERT(r == 0); /* Emulate EUR inputs by LEFT ALT+NUMPAD ASCII KeyComos */ make_key_event_records(VK_MENU, 0, FALSE, alt_records); @@ -296,21 +296,21 @@ TEST_IMPL(tty_composing_character) { WriteConsoleInputW(handle, &alt_records[0], 1, &written); make_key_event_records(VK_NUMPAD0, LEFT_ALT_PRESSED, FALSE, records); WriteConsoleInputW(handle, records, ARRAY_SIZE(records), &written); - ASSERT_EQ(written, ARRAY_SIZE(records)); + ASSERT(written == ARRAY_SIZE(records)); make_key_event_records(VK_NUMPAD1, LEFT_ALT_PRESSED, FALSE, records); WriteConsoleInputW(handle, records, ARRAY_SIZE(records), &written); - ASSERT_EQ(written, ARRAY_SIZE(records)); + ASSERT(written == ARRAY_SIZE(records)); make_key_event_records(VK_NUMPAD2, LEFT_ALT_PRESSED, FALSE, records); WriteConsoleInputW(handle, records, ARRAY_SIZE(records), &written); - ASSERT_EQ(written, ARRAY_SIZE(records)); + ASSERT(written == ARRAY_SIZE(records)); make_key_event_records(VK_NUMPAD8, LEFT_ALT_PRESSED, FALSE, records); WriteConsoleInputW(handle, records, ARRAY_SIZE(records), &written); - ASSERT_EQ(written, ARRAY_SIZE(records)); + ASSERT(written == ARRAY_SIZE(records)); WriteConsoleInputW(handle, &alt_records[1], 1, &written); uv_run(loop, UV_RUN_DEFAULT); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-tty-escape-sequence-processing.c b/test/test-tty-escape-sequence-processing.c index 4a041db..5f04291 100644 --- a/test/test-tty-escape-sequence-processing.c +++ b/test/test-tty-escape-sequence-processing.c @@ -165,8 +165,8 @@ static void write_console(uv_tty_t* tty_out, char* src) { buf.len = strlen(buf.base); r = uv_try_write((uv_stream_t*) tty_out, &buf, 1); - ASSERT_GE(r, 0); - ASSERT_EQ((unsigned int) r, buf.len); + ASSERT(r >= 0); + ASSERT((unsigned int) r == buf.len); } static void setup_screen(uv_tty_t* tty_out) { @@ -178,8 +178,8 @@ static void setup_screen(uv_tty_t* tty_out) { origin.X = 0; origin.Y = info.srWindow.Top; ASSERT(FillConsoleOutputCharacter( - tty_out->handle, '.', length, origin, &number_of_written)); - ASSERT_EQ(length, number_of_written); + tty_out->handle, '.', length, origin, &number_of_written)); + ASSERT(length == number_of_written); } static void clear_screen(uv_tty_t* tty_out, struct screen_info* si) { @@ -192,10 +192,10 @@ static void clear_screen(uv_tty_t* tty_out, struct screen_info* si) { origin.Y = info.srWindow.Top; FillConsoleOutputCharacterA( tty_out->handle, ' ', length, origin, &number_of_written); - ASSERT_EQ(length, number_of_written); + ASSERT(length == number_of_written); FillConsoleOutputAttribute( tty_out->handle, si->default_attr, length, origin, &number_of_written); - ASSERT_EQ(length, number_of_written); + ASSERT(length == number_of_written); } static void free_screen(struct captured_screen* cs) { @@ -216,11 +216,11 @@ static void capture_screen(uv_tty_t* tty_out, struct captured_screen* cs) { cs->attributes = (WORD*) malloc(cs->si.length * sizeof(*cs->attributes)); ASSERT_NOT_NULL(cs->attributes); ASSERT(ReadConsoleOutputCharacter( - tty_out->handle, cs->text, cs->si.length, origin, &length)); - ASSERT_EQ((unsigned int) cs->si.length, length); + tty_out->handle, cs->text, cs->si.length, origin, &length)); + ASSERT((unsigned int) cs->si.length == length); ASSERT(ReadConsoleOutputAttribute( - tty_out->handle, cs->attributes, cs->si.length, origin, &length)); - ASSERT_EQ((unsigned int) cs->si.length, length); + tty_out->handle, cs->attributes, cs->si.length, origin, &length)); + ASSERT((unsigned int) cs->si.length == length); } static void make_expect_screen_erase(struct captured_screen* cs, @@ -261,8 +261,8 @@ static void make_expect_screen_erase(struct captured_screen* cs, } else { ASSERT(FALSE); } - ASSERT_PTR_LT(start, end); - ASSERT_LE(end - cs->text, cs->si.length); + ASSERT(start < end); + ASSERT(end - cs->text <= cs->si.length); for (; start < end; start++) { *start = ' '; } @@ -360,13 +360,13 @@ static void initialize_tty(uv_tty_t* tty_out) { NULL, CONSOLE_TEXTMODE_BUFFER, NULL); - ASSERT_PTR_NE(handle, INVALID_HANDLE_VALUE); + ASSERT(handle != INVALID_HANDLE_VALUE); ttyout_fd = _open_osfhandle((intptr_t) handle, 0); - ASSERT_GE(ttyout_fd, 0); - ASSERT_EQ(UV_TTY, uv_guess_handle(ttyout_fd)); + ASSERT(ttyout_fd >= 0); + ASSERT(UV_TTY == uv_guess_handle(ttyout_fd)); r = uv_tty_init(uv_default_loop(), tty_out, ttyout_fd, 0); /* Writable. */ - ASSERT_OK(r); + ASSERT(r == 0); } static void terminate_tty(uv_tty_t* tty_out) { @@ -394,16 +394,16 @@ TEST_IMPL(tty_cursor_up) { snprintf(buffer, sizeof(buffer), "%sA", CSI); write_console(&tty_out, buffer); get_cursor_position(&tty_out, &cursor_pos); - ASSERT_EQ(cursor_pos_old.Y - 1, cursor_pos.Y); - ASSERT_EQ(cursor_pos_old.X, cursor_pos.X); + ASSERT(cursor_pos_old.Y - 1 == cursor_pos.Y); + ASSERT(cursor_pos_old.X == cursor_pos.X); /* cursor up nth times */ cursor_pos_old = cursor_pos; snprintf(buffer, sizeof(buffer), "%s%dA", CSI, si.height / 4); write_console(&tty_out, buffer); get_cursor_position(&tty_out, &cursor_pos); - ASSERT_EQ(cursor_pos_old.Y - si.height / 4, cursor_pos.Y); - ASSERT_EQ(cursor_pos_old.X, cursor_pos.X); + ASSERT(cursor_pos_old.Y - si.height / 4 == cursor_pos.Y); + ASSERT(cursor_pos_old.X == cursor_pos.X); /* cursor up from Window top does nothing */ cursor_pos_old.X = 1; @@ -412,15 +412,15 @@ TEST_IMPL(tty_cursor_up) { snprintf(buffer, sizeof(buffer), "%sA", CSI); write_console(&tty_out, buffer); get_cursor_position(&tty_out, &cursor_pos); - ASSERT_EQ(cursor_pos_old.Y, cursor_pos.Y); - ASSERT_EQ(cursor_pos_old.X, cursor_pos.X); + ASSERT(cursor_pos_old.Y == cursor_pos.Y); + ASSERT(cursor_pos_old.X == cursor_pos.X); ASSERT(!is_scrolling(&tty_out, si)); terminate_tty(&tty_out); uv_run(loop, UV_RUN_DEFAULT); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -445,16 +445,16 @@ TEST_IMPL(tty_cursor_down) { snprintf(buffer, sizeof(buffer), "%sB", CSI); write_console(&tty_out, buffer); get_cursor_position(&tty_out, &cursor_pos); - ASSERT_EQ(cursor_pos_old.Y + 1, cursor_pos.Y); - ASSERT_EQ(cursor_pos_old.X, cursor_pos.X); + ASSERT(cursor_pos_old.Y + 1 == cursor_pos.Y); + ASSERT(cursor_pos_old.X == cursor_pos.X); /* cursor down nth times */ cursor_pos_old = cursor_pos; snprintf(buffer, sizeof(buffer), "%s%dB", CSI, si.height / 4); write_console(&tty_out, buffer); get_cursor_position(&tty_out, &cursor_pos); - ASSERT_EQ(cursor_pos_old.Y + si.height / 4, cursor_pos.Y); - ASSERT_EQ(cursor_pos_old.X, cursor_pos.X); + ASSERT(cursor_pos_old.Y + si.height / 4 == cursor_pos.Y); + ASSERT(cursor_pos_old.X == cursor_pos.X); /* cursor down from bottom line does nothing */ cursor_pos_old.X = si.width / 2; @@ -463,15 +463,15 @@ TEST_IMPL(tty_cursor_down) { snprintf(buffer, sizeof(buffer), "%sB", CSI); write_console(&tty_out, buffer); get_cursor_position(&tty_out, &cursor_pos); - ASSERT_EQ(cursor_pos_old.Y, cursor_pos.Y); - ASSERT_EQ(cursor_pos_old.X, cursor_pos.X); + ASSERT(cursor_pos_old.Y == cursor_pos.Y); + ASSERT(cursor_pos_old.X == cursor_pos.X); ASSERT(!is_scrolling(&tty_out, si)); terminate_tty(&tty_out); uv_run(loop, UV_RUN_DEFAULT); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -496,16 +496,16 @@ TEST_IMPL(tty_cursor_forward) { snprintf(buffer, sizeof(buffer), "%sC", CSI); write_console(&tty_out, buffer); get_cursor_position(&tty_out, &cursor_pos); - ASSERT_EQ(cursor_pos_old.Y, cursor_pos.Y); - ASSERT_EQ(cursor_pos_old.X + 1, cursor_pos.X); + ASSERT(cursor_pos_old.Y == cursor_pos.Y); + ASSERT(cursor_pos_old.X + 1 == cursor_pos.X); /* cursor forward nth times */ cursor_pos_old = cursor_pos; snprintf(buffer, sizeof(buffer), "%s%dC", CSI, si.width / 4); write_console(&tty_out, buffer); get_cursor_position(&tty_out, &cursor_pos); - ASSERT_EQ(cursor_pos_old.Y, cursor_pos.Y); - ASSERT_EQ(cursor_pos_old.X + si.width / 4, cursor_pos.X); + ASSERT(cursor_pos_old.Y == cursor_pos.Y); + ASSERT(cursor_pos_old.X + si.width / 4 == cursor_pos.X); /* cursor forward from end of line does nothing*/ cursor_pos_old.X = si.width; @@ -514,8 +514,8 @@ TEST_IMPL(tty_cursor_forward) { snprintf(buffer, sizeof(buffer), "%sC", CSI); write_console(&tty_out, buffer); get_cursor_position(&tty_out, &cursor_pos); - ASSERT_EQ(cursor_pos_old.Y, cursor_pos.Y); - ASSERT_EQ(cursor_pos_old.X, cursor_pos.X); + ASSERT(cursor_pos_old.Y == cursor_pos.Y); + ASSERT(cursor_pos_old.X == cursor_pos.X); /* cursor forward from end of screen does nothing */ cursor_pos_old.X = si.width; @@ -524,15 +524,15 @@ TEST_IMPL(tty_cursor_forward) { snprintf(buffer, sizeof(buffer), "%sC", CSI); write_console(&tty_out, buffer); get_cursor_position(&tty_out, &cursor_pos); - ASSERT_EQ(cursor_pos_old.Y, cursor_pos.Y); - ASSERT_EQ(cursor_pos_old.X, cursor_pos.X); + ASSERT(cursor_pos_old.Y == cursor_pos.Y); + ASSERT(cursor_pos_old.X == cursor_pos.X); ASSERT(!is_scrolling(&tty_out, si)); terminate_tty(&tty_out); uv_run(loop, UV_RUN_DEFAULT); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -557,16 +557,16 @@ TEST_IMPL(tty_cursor_back) { snprintf(buffer, sizeof(buffer), "%sD", CSI); write_console(&tty_out, buffer); get_cursor_position(&tty_out, &cursor_pos); - ASSERT_EQ(cursor_pos_old.Y, cursor_pos.Y); - ASSERT_EQ(cursor_pos_old.X - 1, cursor_pos.X); + ASSERT(cursor_pos_old.Y == cursor_pos.Y); + ASSERT(cursor_pos_old.X - 1 == cursor_pos.X); /* cursor back nth times */ cursor_pos_old = cursor_pos; snprintf(buffer, sizeof(buffer), "%s%dD", CSI, si.width / 4); write_console(&tty_out, buffer); get_cursor_position(&tty_out, &cursor_pos); - ASSERT_EQ(cursor_pos_old.Y, cursor_pos.Y); - ASSERT_EQ(cursor_pos_old.X - si.width / 4, cursor_pos.X); + ASSERT(cursor_pos_old.Y == cursor_pos.Y); + ASSERT(cursor_pos_old.X - si.width / 4 == cursor_pos.X); /* cursor back from beginning of line does nothing */ cursor_pos_old.X = 1; @@ -575,8 +575,8 @@ TEST_IMPL(tty_cursor_back) { snprintf(buffer, sizeof(buffer), "%sD", CSI); write_console(&tty_out, buffer); get_cursor_position(&tty_out, &cursor_pos); - ASSERT_EQ(cursor_pos_old.Y, cursor_pos.Y); - ASSERT_EQ(cursor_pos_old.X, cursor_pos.X); + ASSERT(cursor_pos_old.Y == cursor_pos.Y); + ASSERT(cursor_pos_old.X == cursor_pos.X); /* cursor back from top of screen does nothing */ cursor_pos_old.X = 1; @@ -585,15 +585,15 @@ TEST_IMPL(tty_cursor_back) { snprintf(buffer, sizeof(buffer), "%sD", CSI); write_console(&tty_out, buffer); get_cursor_position(&tty_out, &cursor_pos); - ASSERT_EQ(1, cursor_pos.Y); - ASSERT_EQ(1, cursor_pos.X); + ASSERT(1 == cursor_pos.Y); + ASSERT(1 == cursor_pos.X); ASSERT(!is_scrolling(&tty_out, si)); terminate_tty(&tty_out); uv_run(loop, UV_RUN_DEFAULT); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -618,16 +618,16 @@ TEST_IMPL(tty_cursor_next_line) { snprintf(buffer, sizeof(buffer), "%sE", CSI); write_console(&tty_out, buffer); get_cursor_position(&tty_out, &cursor_pos); - ASSERT_EQ(cursor_pos_old.Y + 1, cursor_pos.Y); - ASSERT_EQ(1, cursor_pos.X); + ASSERT(cursor_pos_old.Y + 1 == cursor_pos.Y); + ASSERT(1 == cursor_pos.X); /* cursor next line nth times */ cursor_pos_old = cursor_pos; snprintf(buffer, sizeof(buffer), "%s%dE", CSI, si.height / 4); write_console(&tty_out, buffer); get_cursor_position(&tty_out, &cursor_pos); - ASSERT_EQ(cursor_pos_old.Y + si.height / 4, cursor_pos.Y); - ASSERT_EQ(1, cursor_pos.X); + ASSERT(cursor_pos_old.Y + si.height / 4 == cursor_pos.Y); + ASSERT(1 == cursor_pos.X); /* cursor next line from buttom row moves beginning of line */ cursor_pos_old.X = si.width / 2; @@ -636,15 +636,15 @@ TEST_IMPL(tty_cursor_next_line) { snprintf(buffer, sizeof(buffer), "%sE", CSI); write_console(&tty_out, buffer); get_cursor_position(&tty_out, &cursor_pos); - ASSERT_EQ(cursor_pos_old.Y, cursor_pos.Y); - ASSERT_EQ(1, cursor_pos.X); + ASSERT(cursor_pos_old.Y == cursor_pos.Y); + ASSERT(1 == cursor_pos.X); ASSERT(!is_scrolling(&tty_out, si)); terminate_tty(&tty_out); uv_run(loop, UV_RUN_DEFAULT); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -669,16 +669,16 @@ TEST_IMPL(tty_cursor_previous_line) { snprintf(buffer, sizeof(buffer), "%sF", CSI); write_console(&tty_out, buffer); get_cursor_position(&tty_out, &cursor_pos); - ASSERT_EQ(cursor_pos_old.Y - 1, cursor_pos.Y); - ASSERT_EQ(1, cursor_pos.X); + ASSERT(cursor_pos_old.Y - 1 == cursor_pos.Y); + ASSERT(1 == cursor_pos.X); /* cursor previous line nth times */ cursor_pos_old = cursor_pos; snprintf(buffer, sizeof(buffer), "%s%dF", CSI, si.height / 4); write_console(&tty_out, buffer); get_cursor_position(&tty_out, &cursor_pos); - ASSERT_EQ(cursor_pos_old.Y - si.height / 4, cursor_pos.Y); - ASSERT_EQ(1, cursor_pos.X); + ASSERT(cursor_pos_old.Y - si.height / 4 == cursor_pos.Y); + ASSERT(1 == cursor_pos.X); /* cursor previous line from top of screen does nothing */ cursor_pos_old.X = 1; @@ -687,15 +687,15 @@ TEST_IMPL(tty_cursor_previous_line) { snprintf(buffer, sizeof(buffer), "%sD", CSI); write_console(&tty_out, buffer); get_cursor_position(&tty_out, &cursor_pos); - ASSERT_EQ(1, cursor_pos.Y); - ASSERT_EQ(1, cursor_pos.X); + ASSERT(1 == cursor_pos.Y); + ASSERT(1 == cursor_pos.X); ASSERT(!is_scrolling(&tty_out, si)); terminate_tty(&tty_out); uv_run(loop, UV_RUN_DEFAULT); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -720,28 +720,28 @@ TEST_IMPL(tty_cursor_horizontal_move_absolute) { snprintf(buffer, sizeof(buffer), "%sG", CSI); write_console(&tty_out, buffer); get_cursor_position(&tty_out, &cursor_pos); - ASSERT_EQ(1, cursor_pos.X); - ASSERT_EQ(cursor_pos_old.Y, cursor_pos.Y); + ASSERT(1 == cursor_pos.X); + ASSERT(cursor_pos_old.Y == cursor_pos.Y); /* Move cursor to nth character */ snprintf(buffer, sizeof(buffer), "%s%dG", CSI, si.width / 4); write_console(&tty_out, buffer); get_cursor_position(&tty_out, &cursor_pos); - ASSERT_EQ(si.width / 4, cursor_pos.X); - ASSERT_EQ(cursor_pos_old.Y, cursor_pos.Y); + ASSERT(si.width / 4 == cursor_pos.X); + ASSERT(cursor_pos_old.Y == cursor_pos.Y); /* Moving out of screen will fit within screen */ snprintf(buffer, sizeof(buffer), "%s%dG", CSI, si.width + 1); write_console(&tty_out, buffer); get_cursor_position(&tty_out, &cursor_pos); - ASSERT_EQ(si.width, cursor_pos.X); - ASSERT_EQ(cursor_pos_old.Y, cursor_pos.Y); + ASSERT(si.width == cursor_pos.X); + ASSERT(cursor_pos_old.Y == cursor_pos.Y); terminate_tty(&tty_out); uv_run(loop, UV_RUN_DEFAULT); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -766,38 +766,38 @@ TEST_IMPL(tty_cursor_move_absolute) { snprintf(buffer, sizeof(buffer), "%sH", CSI); write_console(&tty_out, buffer); get_cursor_position(&tty_out, &cursor_pos); - ASSERT_EQ(1, cursor_pos.X); - ASSERT_EQ(1, cursor_pos.Y); + ASSERT(1 == cursor_pos.X); + ASSERT(1 == cursor_pos.Y); /* Move the cursor to the middle of the screen */ snprintf( buffer, sizeof(buffer), "%s%d;%df", CSI, si.height / 2, si.width / 2); write_console(&tty_out, buffer); get_cursor_position(&tty_out, &cursor_pos); - ASSERT_EQ(si.width / 2, cursor_pos.X); - ASSERT_EQ(si.height / 2, cursor_pos.Y); + ASSERT(si.width / 2 == cursor_pos.X); + ASSERT(si.height / 2 == cursor_pos.Y); /* Moving out of screen will fit within screen */ snprintf( buffer, sizeof(buffer), "%s%d;%df", CSI, si.height / 2, si.width + 1); write_console(&tty_out, buffer); get_cursor_position(&tty_out, &cursor_pos); - ASSERT_EQ(si.width, cursor_pos.X); - ASSERT_EQ(si.height / 2, cursor_pos.Y); + ASSERT(si.width == cursor_pos.X); + ASSERT(si.height / 2 == cursor_pos.Y); snprintf( buffer, sizeof(buffer), "%s%d;%df", CSI, si.height + 1, si.width / 2); write_console(&tty_out, buffer); get_cursor_position(&tty_out, &cursor_pos); - ASSERT_EQ(si.width / 2, cursor_pos.X); - ASSERT_EQ(si.height, cursor_pos.Y); + ASSERT(si.width / 2 == cursor_pos.X); + ASSERT(si.height == cursor_pos.Y); ASSERT(!is_scrolling(&tty_out, si)); terminate_tty(&tty_out); uv_run(loop, UV_RUN_DEFAULT); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -831,7 +831,7 @@ TEST_IMPL(tty_hide_show_cursor) { uv_run(loop, UV_RUN_DEFAULT); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -905,7 +905,7 @@ TEST_IMPL(tty_erase) { uv_run(loop, UV_RUN_DEFAULT); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -979,7 +979,7 @@ TEST_IMPL(tty_erase_line) { uv_run(loop, UV_RUN_DEFAULT); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -1000,54 +1000,49 @@ TEST_IMPL(tty_set_cursor_shape) { set_cursor_size(&tty_out, CURSOR_SIZE_MIDDLE); snprintf(buffer, sizeof(buffer), "%s q", CSI); write_console(&tty_out, buffer); - ASSERT_EQ(get_cursor_size(&tty_out), CURSOR_SIZE_LARGE); + ASSERT(get_cursor_size(&tty_out) == CURSOR_SIZE_LARGE); /* cursor size large */ set_cursor_size(&tty_out, CURSOR_SIZE_MIDDLE); snprintf(buffer, sizeof(buffer), "%s1 q", CSI); write_console(&tty_out, buffer); - ASSERT_EQ(get_cursor_size(&tty_out), CURSOR_SIZE_LARGE); + ASSERT(get_cursor_size(&tty_out) == CURSOR_SIZE_LARGE); set_cursor_size(&tty_out, CURSOR_SIZE_MIDDLE); snprintf(buffer, sizeof(buffer), "%s2 q", CSI); write_console(&tty_out, buffer); - ASSERT_EQ(get_cursor_size(&tty_out), CURSOR_SIZE_LARGE); + ASSERT(get_cursor_size(&tty_out) == CURSOR_SIZE_LARGE); /* cursor size small */ set_cursor_size(&tty_out, CURSOR_SIZE_MIDDLE); snprintf(buffer, sizeof(buffer), "%s3 q", CSI); write_console(&tty_out, buffer); - ASSERT_EQ(get_cursor_size(&tty_out), CURSOR_SIZE_SMALL); + ASSERT(get_cursor_size(&tty_out) == CURSOR_SIZE_SMALL); set_cursor_size(&tty_out, CURSOR_SIZE_MIDDLE); snprintf(buffer, sizeof(buffer), "%s6 q", CSI); write_console(&tty_out, buffer); - ASSERT_EQ(get_cursor_size(&tty_out), CURSOR_SIZE_SMALL); + ASSERT(get_cursor_size(&tty_out) == CURSOR_SIZE_SMALL); /* Nothing occurs with arguments outside valid range */ set_cursor_size(&tty_out, CURSOR_SIZE_MIDDLE); snprintf(buffer, sizeof(buffer), "%s7 q", CSI); write_console(&tty_out, buffer); - ASSERT_EQ(get_cursor_size(&tty_out), CURSOR_SIZE_MIDDLE); + ASSERT(get_cursor_size(&tty_out) == CURSOR_SIZE_MIDDLE); /* restore cursor size if arguments is zero */ snprintf(buffer, sizeof(buffer), "%s0 q", CSI); write_console(&tty_out, buffer); - ASSERT_EQ(get_cursor_size(&tty_out), saved_cursor_size); + ASSERT(get_cursor_size(&tty_out) == saved_cursor_size); terminate_tty(&tty_out); uv_run(loop, UV_RUN_DEFAULT); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } TEST_IMPL(tty_set_style) { -#if _MSC_VER >= 1920 && _MSC_VER <= 1929 - RETURN_SKIP("Broken on Microsoft Visual Studio 2019, to be investigated. " - "See: https://github.com/libuv/libuv/issues/3304"); -#else - uv_tty_t tty_out; uv_loop_t* loop; COORD cursor_pos; @@ -1075,6 +1070,11 @@ TEST_IMPL(tty_set_style) { WORD attr; int i, length; +#if _MSC_VER >= 1920 && _MSC_VER <= 1929 + RETURN_SKIP("Broken on Microsoft Visual Studio 2019, to be investigated. " + "See: https://github.com/libuv/libuv/issues/3304"); +#endif + loop = uv_default_loop(); initialize_tty(&tty_out); @@ -1121,8 +1121,8 @@ TEST_IMPL(tty_set_style) { ASSERT(compare_screen(&tty_out, &actual, &expect)); } - /* Set foreground and background color */ - ASSERT_EQ(ARRAY_SIZE(fg_attrs), ARRAY_SIZE(bg_attrs)); + /* Set foregroud and background color */ + ASSERT(ARRAY_SIZE(fg_attrs) == ARRAY_SIZE(bg_attrs)); length = ARRAY_SIZE(bg_attrs); for (i = 0; i < length; i++) { capture_screen(&tty_out, &expect); @@ -1237,9 +1237,8 @@ TEST_IMPL(tty_set_style) { uv_run(loop, UV_RUN_DEFAULT); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; -#endif } @@ -1271,8 +1270,8 @@ TEST_IMPL(tty_save_restore_cursor_position) { snprintf(buffer, sizeof(buffer), "%su", CSI); write_console(&tty_out, buffer); get_cursor_position(&tty_out, &cursor_pos); - ASSERT_EQ(cursor_pos.X, cursor_pos_old.X); - ASSERT_EQ(cursor_pos.Y, cursor_pos_old.Y); + ASSERT(cursor_pos.X == cursor_pos_old.X); + ASSERT(cursor_pos.Y == cursor_pos_old.Y); cursor_pos_old.X = si.width / 2; cursor_pos_old.Y = si.height / 2; @@ -1290,14 +1289,14 @@ TEST_IMPL(tty_save_restore_cursor_position) { snprintf(buffer, sizeof(buffer), "%s8", ESC); write_console(&tty_out, buffer); get_cursor_position(&tty_out, &cursor_pos); - ASSERT_EQ(cursor_pos.X, cursor_pos_old.X); - ASSERT_EQ(cursor_pos.Y, cursor_pos_old.Y); + ASSERT(cursor_pos.X == cursor_pos_old.X); + ASSERT(cursor_pos.Y == cursor_pos_old.Y); terminate_tty(&tty_out); uv_run(loop, UV_RUN_DEFAULT); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -1332,24 +1331,20 @@ TEST_IMPL(tty_full_reset) { write_console(&tty_out, buffer); capture_screen(&tty_out, &actual); ASSERT(compare_screen(&tty_out, &actual, &expect)); - ASSERT_EQ(get_cursor_size(&tty_out), saved_cursor_size); - ASSERT_EQ(get_cursor_visibility(&tty_out), saved_cursor_visibility); - ASSERT_OK(actual.si.csbi.srWindow.Top); + ASSERT(get_cursor_size(&tty_out) == saved_cursor_size); + ASSERT(get_cursor_visibility(&tty_out) == saved_cursor_visibility); + ASSERT(actual.si.csbi.srWindow.Top == 0); terminate_tty(&tty_out); uv_run(loop, UV_RUN_DEFAULT); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } TEST_IMPL(tty_escape_sequence_processing) { -#if _MSC_VER >= 1920 && _MSC_VER <= 1929 - RETURN_SKIP("Broken on Microsoft Visual Studio 2019, to be investigated. " - "See: https://github.com/libuv/libuv/issues/3304"); -#else uv_tty_t tty_out; uv_loop_t* loop; COORD cursor_pos, cursor_pos_old; @@ -1358,11 +1353,16 @@ TEST_IMPL(tty_escape_sequence_processing) { struct captured_screen actual = {0}, expect = {0}; int dir; +#if _MSC_VER >= 1920 && _MSC_VER <= 1929 + RETURN_SKIP("Broken on Microsoft Visual Studio 2019, to be investigated. " + "See: https://github.com/libuv/libuv/issues/3304"); +#endif + loop = uv_default_loop(); initialize_tty(&tty_out); - /* CSI + finally byte does not output anything */ + /* CSI + finaly byte does not output anything */ cursor_pos.X = 1; cursor_pos.Y = 1; set_cursor_position(&tty_out, cursor_pos); @@ -1375,7 +1375,7 @@ TEST_IMPL(tty_escape_sequence_processing) { capture_screen(&tty_out, &actual); ASSERT(compare_screen(&tty_out, &actual, &expect)); - /* CSI(C1) + finally byte does not output anything */ + /* CSI(C1) + finaly byte does not output anything */ cursor_pos.X = 1; cursor_pos.Y = 1; set_cursor_position(&tty_out, cursor_pos); @@ -1388,7 +1388,7 @@ TEST_IMPL(tty_escape_sequence_processing) { capture_screen(&tty_out, &actual); ASSERT(compare_screen(&tty_out, &actual, &expect)); - /* CSI + intermediate byte + finally byte does not output anything */ + /* CSI + intermediate byte + finaly byte does not output anything */ cursor_pos.X = 1; cursor_pos.Y = 1; set_cursor_position(&tty_out, cursor_pos); @@ -1401,7 +1401,7 @@ TEST_IMPL(tty_escape_sequence_processing) { capture_screen(&tty_out, &actual); ASSERT(compare_screen(&tty_out, &actual, &expect)); - /* CSI + parameter byte + finally byte does not output anything */ + /* CSI + parameter byte + finaly byte does not output anything */ cursor_pos.X = 1; cursor_pos.Y = 1; set_cursor_position(&tty_out, cursor_pos); @@ -1520,8 +1520,8 @@ TEST_IMPL(tty_escape_sequence_processing) { snprintf(buffer, sizeof(buffer), "%s1;%dH", CSI, UINT16_MAX + 1); write_console(&tty_out, buffer); get_cursor_position(&tty_out, &cursor_pos); - ASSERT_EQ(1, cursor_pos.X); - ASSERT_EQ(1, cursor_pos.Y); + ASSERT(cursor_pos.X == 1); + ASSERT(cursor_pos.Y == 1); /* Too many argument are ignored */ cursor_pos.X = 1; @@ -1554,18 +1554,18 @@ TEST_IMPL(tty_escape_sequence_processing) { expect.si.width / 2); write_console(&tty_out, buffer); get_cursor_position(&tty_out, &cursor_pos); - ASSERT_EQ(1, cursor_pos.X); - ASSERT_EQ(1, cursor_pos.Y); + ASSERT(cursor_pos.X == 1); + ASSERT(cursor_pos.Y == 1); /* Invalid sequence are ignored */ saved_cursor_size = get_cursor_size(&tty_out); set_cursor_size(&tty_out, CURSOR_SIZE_MIDDLE); snprintf(buffer, sizeof(buffer), "%s 1q", CSI); write_console(&tty_out, buffer); - ASSERT_EQ(get_cursor_size(&tty_out), CURSOR_SIZE_MIDDLE); + ASSERT(get_cursor_size(&tty_out) == CURSOR_SIZE_MIDDLE); snprintf(buffer, sizeof(buffer), "%s 1 q", CSI); write_console(&tty_out, buffer); - ASSERT_EQ(get_cursor_size(&tty_out), CURSOR_SIZE_MIDDLE); + ASSERT(get_cursor_size(&tty_out) == CURSOR_SIZE_MIDDLE); set_cursor_size(&tty_out, saved_cursor_size); /* #1874 2. */ @@ -1605,7 +1605,7 @@ TEST_IMPL(tty_escape_sequence_processing) { capture_screen(&tty_out, &actual); ASSERT(compare_screen(&tty_out, &actual, &expect)); - /* Finally byte immedately after CSI [ are also output(#1874 1.) */ + /* Finaly byte immedately after CSI [ are also output(#1874 1.) */ cursor_pos.X = expect.si.width / 2; cursor_pos.Y = expect.si.height / 2; set_cursor_position(&tty_out, cursor_pos); @@ -1620,9 +1620,8 @@ TEST_IMPL(tty_escape_sequence_processing) { uv_run(loop, UV_RUN_DEFAULT); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; -#endif } #else diff --git a/test/test-tty.c b/test/test-tty.c index 1b11303..ff7d388 100644 --- a/test/test-tty.c +++ b/test/test-tty.c @@ -28,7 +28,7 @@ #else /* Unix */ # include # include -# if defined(__linux__) && !defined(__ANDROID__) +# if (defined(__linux__) || defined(__GLIBC__)) && !defined(__ANDROID__) # include # elif defined(__OpenBSD__) || defined(__NetBSD__) || defined(__APPLE__) # include @@ -57,7 +57,7 @@ TEST_IMPL(tty) { OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); - ASSERT_PTR_NE(handle, INVALID_HANDLE_VALUE); + ASSERT(handle != INVALID_HANDLE_VALUE); ttyin_fd = _open_osfhandle((intptr_t) handle, 0); handle = CreateFileA("conout$", @@ -67,7 +67,7 @@ TEST_IMPL(tty) { OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); - ASSERT_PTR_NE(handle, INVALID_HANDLE_VALUE); + ASSERT(handle != INVALID_HANDLE_VALUE); ttyout_fd = _open_osfhandle((intptr_t) handle, 0); #else /* unix */ @@ -86,53 +86,57 @@ TEST_IMPL(tty) { } #endif - ASSERT_GE(ttyin_fd, 0); - ASSERT_GE(ttyout_fd, 0); + ASSERT(ttyin_fd >= 0); + ASSERT(ttyout_fd >= 0); - ASSERT_EQ(UV_UNKNOWN_HANDLE, uv_guess_handle(-1)); + ASSERT(UV_UNKNOWN_HANDLE == uv_guess_handle(-1)); - ASSERT_EQ(UV_TTY, uv_guess_handle(ttyin_fd)); - ASSERT_EQ(UV_TTY, uv_guess_handle(ttyout_fd)); + ASSERT(UV_TTY == uv_guess_handle(ttyin_fd)); + ASSERT(UV_TTY == uv_guess_handle(ttyout_fd)); - r = uv_tty_init(loop, &tty_in, ttyin_fd, 1); /* Readable. */ - ASSERT_OK(r); + r = uv_tty_init(uv_default_loop(), &tty_in, ttyin_fd, 1); /* Readable. */ + ASSERT(r == 0); ASSERT(uv_is_readable((uv_stream_t*) &tty_in)); ASSERT(!uv_is_writable((uv_stream_t*) &tty_in)); - r = uv_tty_init(loop, &tty_out, ttyout_fd, 0); /* Writable. */ - ASSERT_OK(r); + r = uv_tty_init(uv_default_loop(), &tty_out, ttyout_fd, 0); /* Writable. */ + ASSERT(r == 0); ASSERT(!uv_is_readable((uv_stream_t*) &tty_out)); ASSERT(uv_is_writable((uv_stream_t*) &tty_out)); r = uv_tty_get_winsize(&tty_out, &width, &height); - ASSERT_OK(r); + ASSERT(r == 0); printf("width=%d height=%d\n", width, height); if (width == 0 && height == 0) { /* Some environments such as containers or Jenkins behave like this * sometimes */ - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return TEST_SKIP; } - ASSERT_GT(width, 0); - ASSERT_GT(height, 0); + /* + * Is it a safe assumption that most people have terminals larger than + * 10x10? + */ + ASSERT(width > 10); + ASSERT(height > 10); /* Turn on raw mode. */ r = uv_tty_set_mode(&tty_in, UV_TTY_MODE_RAW); - ASSERT_OK(r); + ASSERT(r == 0); /* Turn off raw mode. */ r = uv_tty_set_mode(&tty_in, UV_TTY_MODE_NORMAL); - ASSERT_OK(r); + ASSERT(r == 0); /* Calling uv_tty_reset_mode() repeatedly should not clobber errno. */ errno = 0; - ASSERT_OK(uv_tty_reset_mode()); - ASSERT_OK(uv_tty_reset_mode()); - ASSERT_OK(uv_tty_reset_mode()); - ASSERT_OK(errno); + ASSERT(0 == uv_tty_reset_mode()); + ASSERT(0 == uv_tty_reset_mode()); + ASSERT(0 == uv_tty_reset_mode()); + ASSERT(0 == errno); /* TODO check the actual mode! */ @@ -141,7 +145,7 @@ TEST_IMPL(tty) { uv_run(loop, UV_RUN_DEFAULT); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -154,11 +158,11 @@ static void tty_raw_alloc(uv_handle_t* handle, size_t size, uv_buf_t* buf) { static void tty_raw_read(uv_stream_t* tty_in, ssize_t nread, const uv_buf_t* buf) { if (nread > 0) { - ASSERT_EQ(1, nread ); - ASSERT_EQ(buf->base[0], ' '); + ASSERT(nread == 1); + ASSERT(buf->base[0] == ' '); uv_close((uv_handle_t*) tty_in, NULL); } else { - ASSERT_OK(nread); + ASSERT(nread == 0); } } @@ -179,25 +183,25 @@ TEST_IMPL(tty_raw) { OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); - ASSERT_PTR_NE(handle, INVALID_HANDLE_VALUE); + ASSERT(handle != INVALID_HANDLE_VALUE); ttyin_fd = _open_osfhandle((intptr_t) handle, 0); - ASSERT_GE(ttyin_fd, 0); - ASSERT_EQ(UV_TTY, uv_guess_handle(ttyin_fd)); + ASSERT(ttyin_fd >= 0); + ASSERT(UV_TTY == uv_guess_handle(ttyin_fd)); - r = uv_tty_init(loop, &tty_in, ttyin_fd, 1); /* Readable. */ - ASSERT_OK(r); + r = uv_tty_init(uv_default_loop(), &tty_in, ttyin_fd, 1); /* Readable. */ + ASSERT(r == 0); ASSERT(uv_is_readable((uv_stream_t*) &tty_in)); ASSERT(!uv_is_writable((uv_stream_t*) &tty_in)); r = uv_read_start((uv_stream_t*)&tty_in, tty_raw_alloc, tty_raw_read); - ASSERT_OK(r); + ASSERT(r == 0); /* Give uv_tty_line_read_thread time to block on ReadConsoleW */ Sleep(100); /* Turn on raw mode. */ r = uv_tty_set_mode(&tty_in, UV_TTY_MODE_RAW); - ASSERT_OK(r); + ASSERT(r == 0); /* Write ' ' that should be read in raw mode */ record.EventType = KEY_EVENT; @@ -211,7 +215,7 @@ TEST_IMPL(tty_raw) { uv_run(loop, UV_RUN_DEFAULT); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -235,15 +239,15 @@ TEST_IMPL(tty_empty_write) { OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); - ASSERT_PTR_NE(handle, INVALID_HANDLE_VALUE); + ASSERT(handle != INVALID_HANDLE_VALUE); ttyout_fd = _open_osfhandle((intptr_t) handle, 0); - ASSERT_GE(ttyout_fd, 0); + ASSERT(ttyout_fd >= 0); - ASSERT_EQ(UV_TTY, uv_guess_handle(ttyout_fd)); + ASSERT(UV_TTY == uv_guess_handle(ttyout_fd)); - r = uv_tty_init(loop, &tty_out, ttyout_fd, 0); /* Writable. */ - ASSERT_OK(r); + r = uv_tty_init(uv_default_loop(), &tty_out, ttyout_fd, 0); /* Writable. */ + ASSERT(r == 0); ASSERT(!uv_is_readable((uv_stream_t*) &tty_out)); ASSERT(uv_is_writable((uv_stream_t*) &tty_out)); @@ -251,13 +255,13 @@ TEST_IMPL(tty_empty_write) { bufs[0].base = &dummy[0]; r = uv_try_write((uv_stream_t*) &tty_out, bufs, 1); - ASSERT_OK(r); + ASSERT(r == 0); uv_close((uv_handle_t*) &tty_out, NULL); uv_run(loop, UV_RUN_DEFAULT); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -281,15 +285,15 @@ TEST_IMPL(tty_large_write) { OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); - ASSERT_PTR_NE(handle, INVALID_HANDLE_VALUE); + ASSERT(handle != INVALID_HANDLE_VALUE); ttyout_fd = _open_osfhandle((intptr_t) handle, 0); - ASSERT_GE(ttyout_fd, 0); + ASSERT(ttyout_fd >= 0); - ASSERT_EQ(UV_TTY, uv_guess_handle(ttyout_fd)); + ASSERT(UV_TTY == uv_guess_handle(ttyout_fd)); - r = uv_tty_init(loop, &tty_out, ttyout_fd, 0); /* Writable. */ - ASSERT_OK(r); + r = uv_tty_init(uv_default_loop(), &tty_out, ttyout_fd, 0); /* Writable. */ + ASSERT(r == 0); memset(dummy, '.', sizeof(dummy) - 1); dummy[sizeof(dummy) - 1] = '\n'; @@ -297,13 +301,13 @@ TEST_IMPL(tty_large_write) { bufs[0] = uv_buf_init(dummy, sizeof(dummy)); r = uv_try_write((uv_stream_t*) &tty_out, bufs, 1); - ASSERT_EQ(10000, r); + ASSERT(r == 10000); uv_close((uv_handle_t*) &tty_out, NULL); uv_run(loop, UV_RUN_DEFAULT); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -321,22 +325,22 @@ TEST_IMPL(tty_raw_cancel) { OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); - ASSERT_PTR_NE(handle, INVALID_HANDLE_VALUE); + ASSERT(handle != INVALID_HANDLE_VALUE); ttyin_fd = _open_osfhandle((intptr_t) handle, 0); - ASSERT_GE(ttyin_fd, 0); - ASSERT_EQ(UV_TTY, uv_guess_handle(ttyin_fd)); + ASSERT(ttyin_fd >= 0); + ASSERT(UV_TTY == uv_guess_handle(ttyin_fd)); r = uv_tty_init(uv_default_loop(), &tty_in, ttyin_fd, 1); /* Readable. */ - ASSERT_OK(r); + ASSERT(r == 0); r = uv_tty_set_mode(&tty_in, UV_TTY_MODE_RAW); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_read_start((uv_stream_t*)&tty_in, tty_raw_alloc, tty_raw_read); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_read_stop((uv_stream_t*) &tty_in); - ASSERT_OK(r); + ASSERT(r == 0); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } #endif @@ -350,35 +354,35 @@ TEST_IMPL(tty_file) { uv_tty_t tty_wo; int fd; - ASSERT_OK(uv_loop_init(&loop)); + ASSERT(0 == uv_loop_init(&loop)); fd = open("test/fixtures/empty_file", O_RDONLY); if (fd != -1) { - ASSERT_EQ(UV_EINVAL, uv_tty_init(&loop, &tty, fd, 1)); - ASSERT_OK(close(fd)); + ASSERT(UV_EINVAL == uv_tty_init(&loop, &tty, fd, 1)); + ASSERT(0 == close(fd)); /* test EBADF handling */ - ASSERT_EQ(UV_EINVAL, uv_tty_init(&loop, &tty, fd, 1)); + ASSERT(UV_EINVAL == uv_tty_init(&loop, &tty, fd, 1)); } /* Bug on AIX where '/dev/random' returns 1 from isatty() */ #ifndef _AIX fd = open("/dev/random", O_RDONLY); if (fd != -1) { - ASSERT_EQ(UV_EINVAL, uv_tty_init(&loop, &tty, fd, 1)); - ASSERT_OK(close(fd)); + ASSERT(UV_EINVAL == uv_tty_init(&loop, &tty, fd, 1)); + ASSERT(0 == close(fd)); } #endif /* _AIX */ fd = open("/dev/zero", O_RDONLY); if (fd != -1) { - ASSERT_EQ(UV_EINVAL, uv_tty_init(&loop, &tty, fd, 1)); - ASSERT_OK(close(fd)); + ASSERT(UV_EINVAL == uv_tty_init(&loop, &tty, fd, 1)); + ASSERT(0 == close(fd)); } fd = open("/dev/tty", O_RDWR); if (fd != -1) { - ASSERT_OK(uv_tty_init(&loop, &tty, fd, 1)); - ASSERT_OK(close(fd)); /* TODO: it's indeterminate who owns fd now */ + ASSERT(0 == uv_tty_init(&loop, &tty, fd, 1)); + ASSERT(0 == close(fd)); /* TODO: it's indeterminate who owns fd now */ ASSERT(uv_is_readable((uv_stream_t*) &tty)); ASSERT(uv_is_writable((uv_stream_t*) &tty)); uv_close((uv_handle_t*) &tty, NULL); @@ -388,8 +392,8 @@ TEST_IMPL(tty_file) { fd = open("/dev/tty", O_RDONLY); if (fd != -1) { - ASSERT_OK(uv_tty_init(&loop, &tty_ro, fd, 1)); - ASSERT_OK(close(fd)); /* TODO: it's indeterminate who owns fd now */ + ASSERT(0 == uv_tty_init(&loop, &tty_ro, fd, 1)); + ASSERT(0 == close(fd)); /* TODO: it's indeterminate who owns fd now */ ASSERT(uv_is_readable((uv_stream_t*) &tty_ro)); ASSERT(!uv_is_writable((uv_stream_t*) &tty_ro)); uv_close((uv_handle_t*) &tty_ro, NULL); @@ -399,8 +403,8 @@ TEST_IMPL(tty_file) { fd = open("/dev/tty", O_WRONLY); if (fd != -1) { - ASSERT_OK(uv_tty_init(&loop, &tty_wo, fd, 0)); - ASSERT_OK(close(fd)); /* TODO: it's indeterminate who owns fd now */ + ASSERT(0 == uv_tty_init(&loop, &tty_wo, fd, 0)); + ASSERT(0 == close(fd)); /* TODO: it's indeterminate who owns fd now */ ASSERT(!uv_is_readable((uv_stream_t*) &tty_wo)); ASSERT(uv_is_writable((uv_stream_t*) &tty_wo)); uv_close((uv_handle_t*) &tty_wo, NULL); @@ -409,9 +413,10 @@ TEST_IMPL(tty_file) { } - ASSERT_OK(uv_run(&loop, UV_RUN_DEFAULT)); + ASSERT(0 == uv_run(&loop, UV_RUN_DEFAULT)); + ASSERT(0 == uv_loop_close(&loop)); - MAKE_VALGRIND_HAPPY(&loop); + MAKE_VALGRIND_HAPPY(); #endif return 0; } @@ -428,6 +433,7 @@ TEST_IMPL(tty_pty) { #if defined(__APPLE__) || \ defined(__DragonFly__) || \ defined(__FreeBSD__) || \ + defined(__FreeBSD_kernel__) || \ (defined(__linux__) && !defined(__ANDROID__)) || \ defined(__NetBSD__) || \ defined(__OpenBSD__) @@ -436,14 +442,14 @@ TEST_IMPL(tty_pty) { uv_loop_t loop; uv_tty_t master_tty, slave_tty; - ASSERT_OK(uv_loop_init(&loop)); + ASSERT(0 == uv_loop_init(&loop)); r = openpty(&master_fd, &slave_fd, NULL, NULL, &w); if (r != 0) RETURN_SKIP("No pty available, skipping."); - ASSERT_OK(uv_tty_init(&loop, &slave_tty, slave_fd, 0)); - ASSERT_OK(uv_tty_init(&loop, &master_tty, master_fd, 0)); + ASSERT(0 == uv_tty_init(&loop, &slave_tty, slave_fd, 0)); + ASSERT(0 == uv_tty_init(&loop, &master_tty, master_fd, 0)); ASSERT(uv_is_readable((uv_stream_t*) &slave_tty)); ASSERT(uv_is_writable((uv_stream_t*) &slave_tty)); ASSERT(uv_is_readable((uv_stream_t*) &master_tty)); @@ -451,18 +457,18 @@ TEST_IMPL(tty_pty) { /* Check if the file descriptor was reopened. If it is, * UV_HANDLE_BLOCKING_WRITES (value 0x100000) isn't set on flags. */ - ASSERT_OK((slave_tty.flags & 0x100000)); + ASSERT(0 == (slave_tty.flags & 0x100000)); /* The master_fd of a pty should never be reopened. */ ASSERT(master_tty.flags & 0x100000); - ASSERT_OK(close(slave_fd)); + ASSERT(0 == close(slave_fd)); uv_close((uv_handle_t*) &slave_tty, NULL); - ASSERT_OK(close(master_fd)); + ASSERT(0 == close(master_fd)); uv_close((uv_handle_t*) &master_tty, NULL); - ASSERT_OK(uv_run(&loop, UV_RUN_DEFAULT)); + ASSERT(0 == uv_run(&loop, UV_RUN_DEFAULT)); - MAKE_VALGRIND_HAPPY(&loop); + MAKE_VALGRIND_HAPPY(); #endif return 0; } diff --git a/test/test-udp-alloc-cb-fail.c b/test/test-udp-alloc-cb-fail.c index ae4bbee..6b09801 100644 --- a/test/test-udp-alloc-cb-fail.c +++ b/test/test-udp-alloc-cb-fail.c @@ -27,7 +27,7 @@ #include #define CHECK_HANDLE(handle) \ - ASSERT_NE((uv_udp_t*)(handle) == &server || (uv_udp_t*)(handle) == &client, 0) + ASSERT((uv_udp_t*)(handle) == &server || (uv_udp_t*)(handle) == &client) static uv_udp_t server; static uv_udp_t client; @@ -60,7 +60,7 @@ static void cl_alloc_cb(uv_handle_t* handle, static void close_cb(uv_handle_t* handle) { CHECK_HANDLE(handle); - ASSERT_EQ(1, uv_is_closing(handle)); + ASSERT(1 == uv_is_closing(handle)); close_cb_called++; } @@ -71,8 +71,8 @@ static void cl_recv_cb(uv_udp_t* handle, const struct sockaddr* addr, unsigned flags) { CHECK_HANDLE(handle); - ASSERT_OK(flags); - ASSERT_EQ(nread, UV_ENOBUFS); + ASSERT(flags == 0); + ASSERT(nread == UV_ENOBUFS); cl_recv_cb_called++; @@ -84,11 +84,11 @@ static void cl_send_cb(uv_udp_send_t* req, int status) { int r; ASSERT_NOT_NULL(req); - ASSERT_OK(status); + ASSERT(status == 0); CHECK_HANDLE(req->handle); r = uv_udp_recv_start(req->handle, cl_alloc_cb, cl_recv_cb); - ASSERT_OK(r); + ASSERT(r == 0); cl_send_cb_called++; } @@ -96,7 +96,7 @@ static void cl_send_cb(uv_udp_send_t* req, int status) { static void sv_send_cb(uv_udp_send_t* req, int status) { ASSERT_NOT_NULL(req); - ASSERT_OK(status); + ASSERT(status == 0); CHECK_HANDLE(req->handle); uv_close((uv_handle_t*) req->handle, close_cb); @@ -126,21 +126,21 @@ static void sv_recv_cb(uv_udp_t* handle, } CHECK_HANDLE(handle); - ASSERT_OK(flags); + ASSERT(flags == 0); ASSERT_NOT_NULL(addr); - ASSERT_EQ(4, nread); + ASSERT(nread == 4); ASSERT(!memcmp("PING", rcvbuf->base, nread)); r = uv_udp_recv_stop(handle); - ASSERT_OK(r); + ASSERT(r == 0); req = malloc(sizeof *req); ASSERT_NOT_NULL(req); sndbuf = uv_buf_init("PONG", 4); r = uv_udp_send(req, handle, &sndbuf, 1, addr, sv_send_cb); - ASSERT_OK(r); + ASSERT(r == 0); sv_recv_cb_called++; } @@ -152,21 +152,21 @@ TEST_IMPL(udp_alloc_cb_fail) { uv_buf_t buf; int r; - ASSERT_OK(uv_ip4_addr("0.0.0.0", TEST_PORT, &addr)); + ASSERT(0 == uv_ip4_addr("0.0.0.0", TEST_PORT, &addr)); r = uv_udp_init(uv_default_loop(), &server); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_udp_bind(&server, (const struct sockaddr*) &addr, 0); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_udp_recv_start(&server, sv_alloc_cb, sv_recv_cb); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); + ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); r = uv_udp_init(uv_default_loop(), &client); - ASSERT_OK(r); + ASSERT(r == 0); buf = uv_buf_init("PING", 4); r = uv_udp_send(&req, @@ -175,22 +175,22 @@ TEST_IMPL(udp_alloc_cb_fail) { 1, (const struct sockaddr*) &addr, cl_send_cb); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_OK(close_cb_called); - ASSERT_OK(cl_send_cb_called); - ASSERT_OK(cl_recv_cb_called); - ASSERT_OK(sv_send_cb_called); - ASSERT_OK(sv_recv_cb_called); + ASSERT(close_cb_called == 0); + ASSERT(cl_send_cb_called == 0); + ASSERT(cl_recv_cb_called == 0); + ASSERT(sv_send_cb_called == 0); + ASSERT(sv_recv_cb_called == 0); uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_EQ(1, cl_send_cb_called); - ASSERT_EQ(1, cl_recv_cb_called); - ASSERT_EQ(1, sv_send_cb_called); - ASSERT_EQ(1, sv_recv_cb_called); - ASSERT_EQ(2, close_cb_called); + ASSERT(cl_send_cb_called == 1); + ASSERT(cl_recv_cb_called == 1); + ASSERT(sv_send_cb_called == 1); + ASSERT(sv_recv_cb_called == 1); + ASSERT(close_cb_called == 2); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-udp-bind.c b/test/test-udp-bind.c index 519f9b0..a1e080e 100644 --- a/test/test-udp-bind.c +++ b/test/test-udp-bind.c @@ -33,29 +33,29 @@ TEST_IMPL(udp_bind) { uv_udp_t h1, h2; int r; - ASSERT_OK(uv_ip4_addr("0.0.0.0", TEST_PORT, &addr)); + ASSERT(0 == uv_ip4_addr("0.0.0.0", TEST_PORT, &addr)); loop = uv_default_loop(); r = uv_udp_init(loop, &h1); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_udp_init(loop, &h2); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_udp_bind(&h1, (const struct sockaddr*) &addr, 0); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_udp_bind(&h2, (const struct sockaddr*) &addr, 0); - ASSERT_EQ(r, UV_EADDRINUSE); + ASSERT(r == UV_EADDRINUSE); uv_close((uv_handle_t*) &h1, NULL); uv_close((uv_handle_t*) &h2, NULL); r = uv_run(loop, UV_RUN_DEFAULT); - ASSERT_OK(r); + ASSERT(r == 0); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -66,28 +66,28 @@ TEST_IMPL(udp_bind_reuseaddr) { uv_udp_t h1, h2; int r; - ASSERT_OK(uv_ip4_addr("0.0.0.0", TEST_PORT, &addr)); + ASSERT(0 == uv_ip4_addr("0.0.0.0", TEST_PORT, &addr)); loop = uv_default_loop(); r = uv_udp_init(loop, &h1); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_udp_init(loop, &h2); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_udp_bind(&h1, (const struct sockaddr*) &addr, UV_UDP_REUSEADDR); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_udp_bind(&h2, (const struct sockaddr*) &addr, UV_UDP_REUSEADDR); - ASSERT_OK(r); + ASSERT(r == 0); uv_close((uv_handle_t*) &h1, NULL); uv_close((uv_handle_t*) &h2, NULL); r = uv_run(loop, UV_RUN_DEFAULT); - ASSERT_OK(r); + ASSERT(r == 0); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-udp-connect.c b/test/test-udp-connect.c index 88314ac..0be702e 100644 --- a/test/test-udp-connect.c +++ b/test/test-udp-connect.c @@ -27,7 +27,7 @@ #include #define CHECK_HANDLE(handle) \ - ASSERT_NE((uv_udp_t*)(handle) == &server || (uv_udp_t*)(handle) == &client, 0) + ASSERT((uv_udp_t*)(handle) == &server || (uv_udp_t*)(handle) == &client) static uv_udp_t server; static uv_udp_t client; @@ -45,7 +45,7 @@ static void alloc_cb(uv_handle_t* handle, uv_buf_t* buf) { static char slab[65536]; CHECK_HANDLE(handle); - ASSERT_LE(suggested_size, sizeof(slab)); + ASSERT(suggested_size <= sizeof(slab)); buf->base = slab; buf->len = sizeof(slab); } @@ -62,19 +62,19 @@ static void cl_send_cb(uv_udp_send_t* req, int status) { int r; ASSERT_NOT_NULL(req); - ASSERT_OK(status); + ASSERT(status == 0); CHECK_HANDLE(req->handle); if (++cl_send_cb_called == 1) { uv_udp_connect(&client, NULL); r = uv_udp_send(req, &client, &buf, 1, NULL, cl_send_cb); - ASSERT_EQ(r, UV_EDESTADDRREQ); + ASSERT(r == UV_EDESTADDRREQ); r = uv_udp_send(req, &client, &buf, 1, (const struct sockaddr*) &lo_addr, cl_send_cb); - ASSERT_OK(r); + ASSERT(r == 0); } } @@ -86,9 +86,9 @@ static void sv_recv_cb(uv_udp_t* handle, const struct sockaddr* addr, unsigned flags) { if (nread > 0) { - ASSERT_EQ(4, nread); + ASSERT(nread == 4); ASSERT_NOT_NULL(addr); - ASSERT_OK(memcmp("EXIT", rcvbuf->base, nread)); + ASSERT(memcmp("EXIT", rcvbuf->base, nread) == 0); if (++sv_recv_cb_called == 4) { uv_close((uv_handle_t*) &server, close_cb); uv_close((uv_handle_t*) &client, close_cb); @@ -98,99 +98,96 @@ static void sv_recv_cb(uv_udp_t* handle, TEST_IMPL(udp_connect) { -#if defined(__OpenBSD__) - RETURN_SKIP("Test does not currently work in OpenBSD"); -#endif uv_udp_send_t req; struct sockaddr_in ext_addr; struct sockaddr_in tmp_addr; int r; int addrlen; - ASSERT_OK(uv_ip4_addr("0.0.0.0", TEST_PORT, &lo_addr)); + ASSERT(0 == uv_ip4_addr("0.0.0.0", TEST_PORT, &lo_addr)); r = uv_udp_init(uv_default_loop(), &server); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_udp_bind(&server, (const struct sockaddr*) &lo_addr, 0); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_udp_recv_start(&server, alloc_cb, sv_recv_cb); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_udp_init(uv_default_loop(), &client); - ASSERT_OK(r); + ASSERT(r == 0); buf = uv_buf_init("EXIT", 4); /* connect() to INADDR_ANY fails on Windows with WSAEADDRNOTAVAIL */ - ASSERT_OK(uv_ip4_addr("0.0.0.0", TEST_PORT, &tmp_addr)); + ASSERT_EQ(0, uv_ip4_addr("0.0.0.0", TEST_PORT, &tmp_addr)); r = uv_udp_connect(&client, (const struct sockaddr*) &tmp_addr); #ifdef _WIN32 ASSERT_EQ(r, UV_EADDRNOTAVAIL); #else - ASSERT_OK(r); + ASSERT_EQ(r, 0); r = uv_udp_connect(&client, NULL); - ASSERT_OK(r); + ASSERT_EQ(r, 0); #endif - ASSERT_OK(uv_ip4_addr("8.8.8.8", TEST_PORT, &ext_addr)); - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &lo_addr)); + ASSERT(0 == uv_ip4_addr("8.8.8.8", TEST_PORT, &ext_addr)); + ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &lo_addr)); r = uv_udp_connect(&client, (const struct sockaddr*) &lo_addr); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_udp_connect(&client, (const struct sockaddr*) &ext_addr); - ASSERT_EQ(r, UV_EISCONN); + ASSERT(r == UV_EISCONN); addrlen = sizeof(tmp_addr); r = uv_udp_getpeername(&client, (struct sockaddr*) &tmp_addr, &addrlen); - ASSERT_OK(r); + ASSERT(r == 0); /* To send messages in connected UDP sockets addr must be NULL */ r = uv_udp_try_send(&client, &buf, 1, (const struct sockaddr*) &lo_addr); - ASSERT_EQ(r, UV_EISCONN); + ASSERT(r == UV_EISCONN); r = uv_udp_try_send(&client, &buf, 1, NULL); - ASSERT_EQ(4, r); + ASSERT(r == 4); r = uv_udp_try_send(&client, &buf, 1, (const struct sockaddr*) &ext_addr); - ASSERT_EQ(r, UV_EISCONN); + ASSERT(r == UV_EISCONN); r = uv_udp_connect(&client, NULL); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_udp_connect(&client, NULL); - ASSERT_EQ(r, UV_ENOTCONN); + ASSERT(r == UV_ENOTCONN); addrlen = sizeof(tmp_addr); r = uv_udp_getpeername(&client, (struct sockaddr*) &tmp_addr, &addrlen); - ASSERT_EQ(r, UV_ENOTCONN); + ASSERT(r == UV_ENOTCONN); /* To send messages in disconnected UDP sockets addr must be set */ r = uv_udp_try_send(&client, &buf, 1, (const struct sockaddr*) &lo_addr); - ASSERT_EQ(4, r); + ASSERT(r == 4); r = uv_udp_try_send(&client, &buf, 1, NULL); - ASSERT_EQ(r, UV_EDESTADDRREQ); + ASSERT(r == UV_EDESTADDRREQ); r = uv_udp_connect(&client, (const struct sockaddr*) &lo_addr); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_udp_send(&req, &client, &buf, 1, (const struct sockaddr*) &lo_addr, cl_send_cb); - ASSERT_EQ(r, UV_EISCONN); + ASSERT(r == UV_EISCONN); r = uv_udp_send(&req, &client, &buf, 1, NULL, cl_send_cb); - ASSERT_OK(r); + ASSERT(r == 0); uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_EQ(2, close_cb_called); - ASSERT_EQ(4, sv_recv_cb_called); - ASSERT_EQ(2, cl_send_cb_called); + ASSERT(close_cb_called == 2); + ASSERT(sv_recv_cb_called == 4); + ASSERT(cl_send_cb_called == 2); - ASSERT_OK(client.send_queue_size); - ASSERT_OK(server.send_queue_size); + ASSERT(client.send_queue_size == 0); + ASSERT(server.send_queue_size == 0); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-udp-connect6.c b/test/test-udp-connect6.c index bbc4033..d000daf 100644 --- a/test/test-udp-connect6.c +++ b/test/test-udp-connect6.c @@ -27,7 +27,7 @@ #include #define CHECK_HANDLE(handle) \ - ASSERT_NE((uv_udp_t*)(handle) == &server || (uv_udp_t*)(handle) == &client, 0) + ASSERT((uv_udp_t*)(handle) == &server || (uv_udp_t*)(handle) == &client) static uv_udp_t server; static uv_udp_t client; @@ -62,7 +62,7 @@ static void cl_send_cb(uv_udp_send_t* req, int status) { int r; ASSERT_NOT_NULL(req); - ASSERT_OK(status); + ASSERT_EQ(status, 0); CHECK_HANDLE(req->handle); if (++cl_send_cb_called == 1) { uv_udp_connect(&client, NULL); @@ -74,7 +74,7 @@ static void cl_send_cb(uv_udp_send_t* req, int status) { 1, (const struct sockaddr*) &lo_addr, cl_send_cb); - ASSERT_OK(r); + ASSERT_EQ(r, 0); } } @@ -86,9 +86,9 @@ static void sv_recv_cb(uv_udp_t* handle, const struct sockaddr* addr, unsigned flags) { if (nread > 0) { - ASSERT_EQ(4, nread); + ASSERT_EQ(nread, 4); ASSERT_NOT_NULL(addr); - ASSERT_OK(memcmp("EXIT", rcvbuf->base, nread)); + ASSERT_EQ(memcmp("EXIT", rcvbuf->base, nread), 0); if (++sv_recv_cb_called == 4) { uv_close((uv_handle_t*) &server, close_cb); uv_close((uv_handle_t*) &client, close_cb); @@ -98,9 +98,6 @@ static void sv_recv_cb(uv_udp_t* handle, TEST_IMPL(udp_connect6) { -#if defined(__OpenBSD__) - RETURN_SKIP("Test does not currently work in OpenBSD"); -#endif uv_udp_send_t req; struct sockaddr_in6 ext_addr; struct sockaddr_in6 tmp_addr; @@ -110,55 +107,55 @@ TEST_IMPL(udp_connect6) { if (!can_ipv6()) RETURN_SKIP("IPv6 not supported"); - ASSERT_OK(uv_ip6_addr("::", TEST_PORT, &lo_addr)); + ASSERT_EQ(0, uv_ip6_addr("::", TEST_PORT, &lo_addr)); r = uv_udp_init(uv_default_loop(), &server); - ASSERT_OK(r); + ASSERT_EQ(r, 0); r = uv_udp_bind(&server, (const struct sockaddr*) &lo_addr, 0); - ASSERT_OK(r); + ASSERT_EQ(r, 0); r = uv_udp_recv_start(&server, alloc_cb, sv_recv_cb); - ASSERT_OK(r); + ASSERT_EQ(r, 0); r = uv_udp_init(uv_default_loop(), &client); - ASSERT_OK(r); + ASSERT_EQ(r, 0); buf = uv_buf_init("EXIT", 4); /* connect() to INADDR_ANY fails on Windows wih WSAEADDRNOTAVAIL */ - ASSERT_OK(uv_ip6_addr("::", TEST_PORT, &tmp_addr)); + ASSERT_EQ(0, uv_ip6_addr("::", TEST_PORT, &tmp_addr)); r = uv_udp_connect(&client, (const struct sockaddr*) &tmp_addr); #ifdef _WIN32 ASSERT_EQ(r, UV_EADDRNOTAVAIL); #else - ASSERT_OK(r); + ASSERT_EQ(r, 0); r = uv_udp_connect(&client, NULL); - ASSERT_OK(r); + ASSERT_EQ(r, 0); #endif - ASSERT_OK(uv_ip6_addr("2001:4860:4860::8888", TEST_PORT, &ext_addr)); - ASSERT_OK(uv_ip6_addr("::1", TEST_PORT, &lo_addr)); + ASSERT_EQ(0, uv_ip6_addr("2001:4860:4860::8888", TEST_PORT, &ext_addr)); + ASSERT_EQ(0, uv_ip6_addr("::1", TEST_PORT, &lo_addr)); r = uv_udp_connect(&client, (const struct sockaddr*) &lo_addr); - ASSERT_OK(r); + ASSERT_EQ(r, 0); r = uv_udp_connect(&client, (const struct sockaddr*) &ext_addr); ASSERT_EQ(r, UV_EISCONN); addrlen = sizeof(tmp_addr); r = uv_udp_getpeername(&client, (struct sockaddr*) &tmp_addr, &addrlen); - ASSERT_OK(r); + ASSERT_EQ(r, 0); /* To send messages in connected UDP sockets addr must be NULL */ r = uv_udp_try_send(&client, &buf, 1, (const struct sockaddr*) &lo_addr); ASSERT_EQ(r, UV_EISCONN); r = uv_udp_try_send(&client, &buf, 1, NULL); - ASSERT_EQ(4, r); + ASSERT_EQ(r, 4); r = uv_udp_try_send(&client, &buf, 1, (const struct sockaddr*) &ext_addr); ASSERT_EQ(r, UV_EISCONN); r = uv_udp_connect(&client, NULL); - ASSERT_OK(r); + ASSERT_EQ(r, 0); r = uv_udp_connect(&client, NULL); ASSERT_EQ(r, UV_ENOTCONN); @@ -168,13 +165,13 @@ TEST_IMPL(udp_connect6) { /* To send messages in disconnected UDP sockets addr must be set */ r = uv_udp_try_send(&client, &buf, 1, (const struct sockaddr*) &lo_addr); - ASSERT_EQ(4, r); + ASSERT_EQ(r, 4); r = uv_udp_try_send(&client, &buf, 1, NULL); ASSERT_EQ(r, UV_EDESTADDRREQ); r = uv_udp_connect(&client, (const struct sockaddr*) &lo_addr); - ASSERT_OK(r); + ASSERT_EQ(r, 0); r = uv_udp_send(&req, &client, &buf, @@ -183,17 +180,17 @@ TEST_IMPL(udp_connect6) { cl_send_cb); ASSERT_EQ(r, UV_EISCONN); r = uv_udp_send(&req, &client, &buf, 1, NULL, cl_send_cb); - ASSERT_OK(r); + ASSERT_EQ(r, 0); uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_EQ(2, close_cb_called); - ASSERT_EQ(4, sv_recv_cb_called); - ASSERT_EQ(2, cl_send_cb_called); + ASSERT_EQ(close_cb_called, 2); + ASSERT_EQ(sv_recv_cb_called, 4); + ASSERT_EQ(cl_send_cb_called, 2); - ASSERT_OK(client.send_queue_size); - ASSERT_OK(server.send_queue_size); + ASSERT_EQ(client.send_queue_size, 0); + ASSERT_EQ(server.send_queue_size, 0); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-udp-create-socket-early.c b/test/test-udp-create-socket-early.c index f2e166a..f7e46ab 100644 --- a/test/test-udp-create-socket-early.c +++ b/test/test-udp-create-socket-early.c @@ -38,39 +38,37 @@ TEST_IMPL(udp_create_early) { uv_os_fd_t fd; int r, namelen; - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); + ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); r = uv_udp_init_ex(uv_default_loop(), &client, AF_INET); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_fileno((const uv_handle_t*) &client, &fd); - ASSERT_OK(r); + ASSERT(r == 0); + ASSERT(fd != INVALID_FD); /* Windows returns WSAEINVAL if the socket is not bound */ #ifndef _WIN32 - ASSERT_NE(fd, INVALID_FD); namelen = sizeof sockname; r = uv_udp_getsockname(&client, (struct sockaddr*) &sockname, &namelen); - ASSERT_OK(r); - ASSERT_EQ(sockname.sin_family, AF_INET); -#else - ASSERT_PTR_NE(fd, INVALID_FD); + ASSERT(r == 0); + ASSERT(sockname.sin_family == AF_INET); #endif r = uv_udp_bind(&client, (const struct sockaddr*) &addr, 0); - ASSERT_OK(r); + ASSERT(r == 0); namelen = sizeof sockname; r = uv_udp_getsockname(&client, (struct sockaddr*) &sockname, &namelen); - ASSERT_OK(r); - ASSERT_OK(memcmp(&addr.sin_addr, - &sockname.sin_addr, - sizeof(addr.sin_addr))); + ASSERT(r == 0); + ASSERT(memcmp(&addr.sin_addr, + &sockname.sin_addr, + sizeof(addr.sin_addr)) == 0); uv_close((uv_handle_t*) &client, NULL); uv_run(uv_default_loop(), UV_RUN_DEFAULT); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -84,40 +82,38 @@ TEST_IMPL(udp_create_early_bad_bind) { if (!can_ipv6()) RETURN_SKIP("IPv6 not supported"); - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); + ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); r = uv_udp_init_ex(uv_default_loop(), &client, AF_INET6); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_fileno((const uv_handle_t*) &client, &fd); - ASSERT_OK(r); + ASSERT(r == 0); + ASSERT(fd != INVALID_FD); /* Windows returns WSAEINVAL if the socket is not bound */ -#ifndef _WIN32 - ASSERT_NE(fd, INVALID_FD); - { +#ifndef _WIN32 + { int namelen; struct sockaddr_in6 sockname; namelen = sizeof sockname; r = uv_udp_getsockname(&client, (struct sockaddr*) &sockname, &namelen); - ASSERT_OK(r); - ASSERT_EQ(sockname.sin6_family, AF_INET6); + ASSERT(r == 0); + ASSERT(sockname.sin6_family == AF_INET6); } -#else - ASSERT_PTR_NE(fd, INVALID_FD); #endif r = uv_udp_bind(&client, (const struct sockaddr*) &addr, 0); #if !defined(_WIN32) && !defined(__CYGWIN__) && !defined(__MSYS__) - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); #else - ASSERT_EQ(r, UV_EFAULT); + ASSERT(r == UV_EFAULT); #endif uv_close((uv_handle_t*) &client, NULL); uv_run(uv_default_loop(), UV_RUN_DEFAULT); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -127,13 +123,13 @@ TEST_IMPL(udp_create_early_bad_domain) { int r; r = uv_udp_init_ex(uv_default_loop(), &client, 47); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); r = uv_udp_init_ex(uv_default_loop(), &client, 1024); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); uv_run(uv_default_loop(), UV_RUN_DEFAULT); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-udp-dgram-too-big.c b/test/test-udp-dgram-too-big.c index 8fae756..bd44c42 100644 --- a/test/test-udp-dgram-too-big.c +++ b/test/test-udp-dgram-too-big.c @@ -27,10 +27,10 @@ #include #define CHECK_HANDLE(handle) \ - ASSERT_PTR_EQ((uv_udp_t*)(handle), &handle_) + ASSERT((uv_udp_t*)(handle) == &handle_) #define CHECK_REQ(req) \ - ASSERT_PTR_EQ((req), &req_); + ASSERT((req) == &req_); static uv_udp_t handle_; static uv_udp_send_t req_; @@ -49,7 +49,7 @@ static void send_cb(uv_udp_send_t* req, int status) { CHECK_REQ(req); CHECK_HANDLE(req->handle); - ASSERT_EQ(status, UV_EMSGSIZE); + ASSERT(status == UV_EMSGSIZE); uv_close((uv_handle_t*)req->handle, close_cb); send_cb_called++; @@ -65,10 +65,10 @@ TEST_IMPL(udp_dgram_too_big) { memset(dgram, 42, sizeof dgram); /* silence valgrind */ r = uv_udp_init(uv_default_loop(), &handle_); - ASSERT_OK(r); + ASSERT(r == 0); buf = uv_buf_init(dgram, sizeof dgram); - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); + ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); r = uv_udp_send(&req_, &handle_, @@ -76,16 +76,16 @@ TEST_IMPL(udp_dgram_too_big) { 1, (const struct sockaddr*) &addr, send_cb); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_OK(close_cb_called); - ASSERT_OK(send_cb_called); + ASSERT(close_cb_called == 0); + ASSERT(send_cb_called == 0); uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_EQ(1, send_cb_called); - ASSERT_EQ(1, close_cb_called); + ASSERT(send_cb_called == 1); + ASSERT(close_cb_called == 1); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-udp-ipv6.c b/test/test-udp-ipv6.c index 8ad80b9..7099953 100644 --- a/test/test-udp-ipv6.c +++ b/test/test-udp-ipv6.c @@ -26,17 +26,17 @@ #include #include -#if defined(__FreeBSD__) || defined(__NetBSD__) +#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__NetBSD__) #include #endif -#define CHECK_HANDLE(handle) \ - ASSERT_NE((uv_udp_t*)(handle) == &server \ - || (uv_udp_t*)(handle) == &client \ - || (uv_timer_t*)(handle) == &timeout, 0) +#define CHECK_HANDLE(handle) \ + ASSERT((uv_udp_t*)(handle) == &server \ + || (uv_udp_t*)(handle) == &client \ + || (uv_timer_t*)(handle) == &timeout) #define CHECK_REQ(req) \ - ASSERT_PTR_EQ((req), &req_); + ASSERT((req) == &req_); static uv_udp_t client; static uv_udp_t server; @@ -49,7 +49,7 @@ static int recv_cb_called; static int close_cb_called; static uint16_t client_port; -#if defined(__FreeBSD__) || defined(__NetBSD__) +#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__NetBSD__) static int can_ipv6_ipv4_dual(void) { int v6only; size_t size = sizeof(int); @@ -81,7 +81,7 @@ static void close_cb(uv_handle_t* handle) { static void send_cb(uv_udp_send_t* req, int status) { CHECK_REQ(req); CHECK_HANDLE(req->handle); - ASSERT_OK(status); + ASSERT(status == 0); send_cb_called++; } @@ -92,7 +92,7 @@ static int is_from_client(const struct sockaddr* addr) { /* Debugging output, and filter out unwanted network traffic */ if (addr != NULL) { - ASSERT_EQ(addr->sa_family, AF_INET6); + ASSERT(addr->sa_family == AF_INET6); addr6 = (struct sockaddr_in6*) addr; r = uv_inet_ntop(addr->sa_family, &addr6->sin6_addr, dst, sizeof(dst)); if (r == 0) @@ -129,7 +129,7 @@ static void ipv6_recv_ok(uv_udp_t* handle, if (!is_from_client(addr) || (nread == 0 && addr == NULL)) return; - ASSERT_EQ(9, nread); + ASSERT(nread == 9); ASSERT(!memcmp(buf->base, data, 9)); recv_cb_called++; } @@ -151,39 +151,31 @@ static void do_test(uv_udp_recv_cb recv_cb, int bind_flags) { char dst[256]; int r; - ASSERT_OK(uv_ip6_addr("::0", TEST_PORT, &addr6)); + ASSERT(0 == uv_ip6_addr("::0", TEST_PORT, &addr6)); r = uv_udp_init(uv_default_loop(), &server); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_udp_bind(&server, (const struct sockaddr*) &addr6, bind_flags); - ASSERT_OK(r); + ASSERT(r == 0); addr6_len = sizeof(addr6); - ASSERT_OK(uv_udp_getsockname(&server, - (struct sockaddr*) &addr6, - &addr6_len)); - ASSERT_OK(uv_inet_ntop(addr6.sin6_family, - &addr6.sin6_addr, - dst, - sizeof(dst))); + ASSERT(uv_udp_getsockname(&server, (struct sockaddr*) &addr6, &addr6_len) == 0); + ASSERT(uv_inet_ntop(addr6.sin6_family, &addr6.sin6_addr, dst, sizeof(dst)) == 0); printf("on [%.*s]:%d\n", (int) sizeof(dst), dst, addr6.sin6_port); r = uv_udp_recv_start(&server, alloc_cb, recv_cb); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_udp_init(uv_default_loop(), &client); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); - ASSERT_OK(uv_inet_ntop(addr.sin_family, &addr.sin_addr, dst, sizeof(dst))); + ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); + ASSERT(uv_inet_ntop(addr.sin_family, &addr.sin_addr, dst, sizeof(dst)) == 0); printf("to [%.*s]:%d\n", (int) sizeof(dst), dst, addr.sin_port); /* Create some unique data to send */ - ASSERT_EQ(9, snprintf(data, - sizeof(data), - "PING%5u", - uv_os_getpid() & 0xFFFF)); + ASSERT(9 == snprintf(data, sizeof(data), "PING%5u", uv_os_getpid() & 0xFFFF)); buf = uv_buf_init(data, 9); printf("sending %s\n", data); @@ -193,29 +185,29 @@ static void do_test(uv_udp_recv_cb recv_cb, int bind_flags) { 1, (const struct sockaddr*) &addr, send_cb); - ASSERT_OK(r); + ASSERT(r == 0); addr_len = sizeof(addr); - ASSERT_OK(uv_udp_getsockname(&client, (struct sockaddr*) &addr, &addr_len)); - ASSERT_OK(uv_inet_ntop(addr.sin_family, &addr.sin_addr, dst, sizeof(dst))); + ASSERT(uv_udp_getsockname(&client, (struct sockaddr*) &addr, &addr_len) == 0); + ASSERT(uv_inet_ntop(addr.sin_family, &addr.sin_addr, dst, sizeof(dst)) == 0); printf("from [%.*s]:%d\n", (int) sizeof(dst), dst, addr.sin_port); client_port = addr.sin_port; r = uv_timer_init(uv_default_loop(), &timeout); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_timer_start(&timeout, timeout_cb, 500, 0); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_OK(close_cb_called); - ASSERT_OK(send_cb_called); - ASSERT_OK(recv_cb_called); + ASSERT(close_cb_called == 0); + ASSERT(send_cb_called == 0); + ASSERT(recv_cb_called == 0); uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_EQ(3, close_cb_called); + ASSERT(close_cb_called == 3); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); } @@ -228,7 +220,7 @@ TEST_IMPL(udp_dual_stack) { if (!can_ipv6()) RETURN_SKIP("IPv6 not supported"); -#if defined(__FreeBSD__) || defined(__NetBSD__) +#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__NetBSD__) if (!can_ipv6_ipv4_dual()) RETURN_SKIP("IPv6-IPv4 dual stack not supported"); #elif defined(__OpenBSD__) @@ -239,8 +231,8 @@ TEST_IMPL(udp_dual_stack) { printf("recv_cb_called %d\n", recv_cb_called); printf("send_cb_called %d\n", send_cb_called); - ASSERT_EQ(1, recv_cb_called); - ASSERT_EQ(1, send_cb_called); + ASSERT(recv_cb_called == 1); + ASSERT(send_cb_called == 1); return 0; } @@ -252,8 +244,8 @@ TEST_IMPL(udp_ipv6_only) { do_test(ipv6_recv_fail, UV_UDP_IPV6ONLY); - ASSERT_OK(recv_cb_called); - ASSERT_EQ(1, send_cb_called); + ASSERT(recv_cb_called == 0); + ASSERT(send_cb_called == 1); return 0; } diff --git a/test/test-udp-mmsg.c b/test/test-udp-mmsg.c index c0e000b..f722608 100644 --- a/test/test-udp-mmsg.c +++ b/test/test-udp-mmsg.c @@ -27,7 +27,7 @@ #include #define CHECK_HANDLE(handle) \ - ASSERT_NE((uv_udp_t*)(handle) == &recver || (uv_udp_t*)(handle) == &sender, 0) + ASSERT((uv_udp_t*)(handle) == &recver || (uv_udp_t*)(handle) == &sender) #define BUFFER_MULTIPLIER 20 #define MAX_DGRAM_SIZE (64 * 1024) @@ -77,7 +77,7 @@ static void recv_cb(uv_udp_t* handle, /* free and return if this is a mmsg free-only callback invocation */ if (flags & UV_UDP_MMSG_FREE) { - ASSERT_OK(nread); + ASSERT_EQ(nread, 0); ASSERT_NULL(addr); free(rcvbuf->base); return; @@ -87,7 +87,7 @@ static void recv_cb(uv_udp_t* handle, /* There can be no more available data for the time being. */ ASSERT_NULL(addr); } else { - ASSERT_EQ(4, nread); + ASSERT_EQ(nread, 4); ASSERT_NOT_NULL(addr); ASSERT_MEM_EQ("PING", rcvbuf->base, nread); received_datagrams++; @@ -110,31 +110,31 @@ TEST_IMPL(udp_mmsg) { uv_buf_t buf; int i; - ASSERT_OK(uv_ip4_addr("0.0.0.0", TEST_PORT, &addr)); + ASSERT_EQ(0, uv_ip4_addr("0.0.0.0", TEST_PORT, &addr)); - ASSERT_OK(uv_udp_init_ex(uv_default_loop(), &recver, - AF_UNSPEC | UV_UDP_RECVMMSG)); + ASSERT_EQ(0, uv_udp_init_ex(uv_default_loop(), &recver, + AF_UNSPEC | UV_UDP_RECVMMSG)); - ASSERT_OK(uv_udp_bind(&recver, (const struct sockaddr*) &addr, 0)); + ASSERT_EQ(0, uv_udp_bind(&recver, (const struct sockaddr*) &addr, 0)); - ASSERT_OK(uv_udp_recv_start(&recver, alloc_cb, recv_cb)); + ASSERT_EQ(0, uv_udp_recv_start(&recver, alloc_cb, recv_cb)); - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); + ASSERT_EQ(0, uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); - ASSERT_OK(uv_udp_init(uv_default_loop(), &sender)); + ASSERT_EQ(0, uv_udp_init(uv_default_loop(), &sender)); buf = uv_buf_init("PING", 4); for (i = 0; i < NUM_SENDS; i++) { ASSERT_EQ(4, uv_udp_try_send(&sender, &buf, 1, (const struct sockaddr*) &addr)); } - ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT)); + ASSERT_EQ(0, uv_run(uv_default_loop(), UV_RUN_DEFAULT)); - ASSERT_EQ(2, close_cb_called); + ASSERT_EQ(close_cb_called, 2); ASSERT_EQ(received_datagrams, NUM_SENDS); - ASSERT_OK(sender.send_queue_size); - ASSERT_OK(recver.send_queue_size); + ASSERT_EQ(sender.send_queue_size, 0); + ASSERT_EQ(recver.send_queue_size, 0); printf("%d allocs for %d recvs\n", alloc_cb_called, recv_cb_called); @@ -144,6 +144,6 @@ TEST_IMPL(udp_mmsg) { else ASSERT_EQ(alloc_cb_called, recv_cb_called); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-udp-multicast-interface.c b/test/test-udp-multicast-interface.c index 2c558c8..bd9a61c 100644 --- a/test/test-udp-multicast-interface.c +++ b/test/test-udp-multicast-interface.c @@ -27,7 +27,7 @@ #include #define CHECK_HANDLE(handle) \ - ASSERT_NE((uv_udp_t*)(handle) == &server || (uv_udp_t*)(handle) == &client, 0) + ASSERT((uv_udp_t*)(handle) == &server || (uv_udp_t*)(handle) == &client) static uv_udp_t server; static uv_udp_t client; @@ -65,17 +65,17 @@ TEST_IMPL(udp_multicast_interface) { struct sockaddr_in addr; struct sockaddr_in baddr; - ASSERT_OK(uv_ip4_addr("239.255.0.1", TEST_PORT, &addr)); + ASSERT(0 == uv_ip4_addr("239.255.0.1", TEST_PORT, &addr)); r = uv_udp_init(uv_default_loop(), &server); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_OK(uv_ip4_addr("0.0.0.0", 0, &baddr)); + ASSERT(0 == uv_ip4_addr("0.0.0.0", 0, &baddr)); r = uv_udp_bind(&server, (const struct sockaddr*)&baddr, 0); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_udp_set_multicast_interface(&server, "0.0.0.0"); - ASSERT_OK(r); + ASSERT(r == 0); /* server sends "PING" */ buf = uv_buf_init("PING", 4); @@ -85,20 +85,20 @@ TEST_IMPL(udp_multicast_interface) { 1, (const struct sockaddr*)&addr, sv_send_cb); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_OK(close_cb_called); - ASSERT_OK(sv_send_cb_called); + ASSERT(close_cb_called == 0); + ASSERT(sv_send_cb_called == 0); /* run the loop till all events are processed */ uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_EQ(1, sv_send_cb_called); - ASSERT_EQ(1, close_cb_called); + ASSERT(sv_send_cb_called == 1); + ASSERT(close_cb_called == 1); - ASSERT_OK(client.send_queue_size); - ASSERT_OK(server.send_queue_size); + ASSERT(client.send_queue_size == 0); + ASSERT(server.send_queue_size == 0); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-udp-multicast-interface6.c b/test/test-udp-multicast-interface6.c index 54fc87e..be11514 100644 --- a/test/test-udp-multicast-interface6.c +++ b/test/test-udp-multicast-interface6.c @@ -27,7 +27,7 @@ #include #define CHECK_HANDLE(handle) \ - ASSERT_NE((uv_udp_t*)(handle) == &server || (uv_udp_t*)(handle) == &client, 0) + ASSERT((uv_udp_t*)(handle) == &server || (uv_udp_t*)(handle) == &client) static uv_udp_t server; static uv_udp_t client; @@ -44,7 +44,7 @@ static void close_cb(uv_handle_t* handle) { static void sv_send_cb(uv_udp_send_t* req, int status) { ASSERT_NOT_NULL(req); - ASSERT_OK(status); + ASSERT(status == 0); CHECK_HANDLE(req->handle); sv_send_cb_called++; @@ -68,21 +68,21 @@ TEST_IMPL(udp_multicast_interface6) { if (!can_ipv6()) RETURN_SKIP("IPv6 not supported"); - ASSERT_OK(uv_ip6_addr("::1", TEST_PORT, &addr)); + ASSERT(0 == uv_ip6_addr("::1", TEST_PORT, &addr)); r = uv_udp_init(uv_default_loop(), &server); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_OK(uv_ip6_addr("::", 0, &baddr)); + ASSERT(0 == uv_ip6_addr("::", 0, &baddr)); r = uv_udp_bind(&server, (const struct sockaddr*)&baddr, 0); - ASSERT_OK(r); + ASSERT(r == 0); -#if defined(__APPLE__) || defined(__FreeBSD__) +#if defined(__APPLE__) || defined(__FreeBSD__) || defined(__FreeBSD_kernel__) r = uv_udp_set_multicast_interface(&server, "::1%lo0"); #else r = uv_udp_set_multicast_interface(&server, NULL); #endif - ASSERT_OK(r); + ASSERT(r == 0); /* server sends "PING" */ buf = uv_buf_init("PING", 4); @@ -92,17 +92,17 @@ TEST_IMPL(udp_multicast_interface6) { 1, (const struct sockaddr*)&addr, sv_send_cb); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_OK(close_cb_called); - ASSERT_OK(sv_send_cb_called); + ASSERT(close_cb_called == 0); + ASSERT(sv_send_cb_called == 0); /* run the loop till all events are processed */ uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_EQ(1, sv_send_cb_called); - ASSERT_EQ(1, close_cb_called); + ASSERT(sv_send_cb_called == 1); + ASSERT(close_cb_called == 1); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-udp-multicast-join.c b/test/test-udp-multicast-join.c index 7e8fbe3..9e603a8 100644 --- a/test/test-udp-multicast-join.c +++ b/test/test-udp-multicast-join.c @@ -27,7 +27,7 @@ #include #define CHECK_HANDLE(handle) \ - ASSERT_NE((uv_udp_t*)(handle) == &server || (uv_udp_t*)(handle) == &client, 0) + ASSERT((uv_udp_t*)(handle) == &server || (uv_udp_t*)(handle) == &client) #define MULTICAST_ADDR "239.255.0.1" @@ -47,7 +47,7 @@ static void alloc_cb(uv_handle_t* handle, uv_buf_t* buf) { static char slab[65536]; CHECK_HANDLE(handle); - ASSERT_LE(suggested_size, sizeof(slab)); + ASSERT(suggested_size <= sizeof(slab)); buf->base = slab; buf->len = sizeof(slab); } @@ -61,7 +61,7 @@ static void close_cb(uv_handle_t* handle) { static void sv_send_cb(uv_udp_send_t* req, int status) { ASSERT_NOT_NULL(req); - ASSERT_OK(status); + ASSERT(status == 0); CHECK_HANDLE(req->handle); sv_send_cb_called++; @@ -77,7 +77,7 @@ static int do_send(uv_udp_send_t* send_req) { buf = uv_buf_init("PING", 4); - ASSERT_OK(uv_ip4_addr(MULTICAST_ADDR, TEST_PORT, &addr)); + ASSERT(0 == uv_ip4_addr(MULTICAST_ADDR, TEST_PORT, &addr)); /* client sends "PING" */ return uv_udp_send(send_req, @@ -95,7 +95,7 @@ static void cl_recv_cb(uv_udp_t* handle, const struct sockaddr* addr, unsigned flags) { CHECK_HANDLE(handle); - ASSERT_OK(flags); + ASSERT(flags == 0); if (nread < 0) { ASSERT(0 && "unexpected error"); @@ -108,7 +108,7 @@ static void cl_recv_cb(uv_udp_t* handle, } ASSERT_NOT_NULL(addr); - ASSERT_EQ(4, nread); + ASSERT(nread == 4); ASSERT(!memcmp("PING", buf->base, nread)); cl_recv_cb_called++; @@ -121,64 +121,61 @@ static void cl_recv_cb(uv_udp_t* handle, char source_addr[64]; r = uv_ip4_name((const struct sockaddr_in*)addr, source_addr, sizeof(source_addr)); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_udp_set_membership(&server, MULTICAST_ADDR, NULL, UV_LEAVE_GROUP); - ASSERT_OK(r); + ASSERT(r == 0); #if !defined(__OpenBSD__) && !defined(__NetBSD__) r = uv_udp_set_source_membership(&server, MULTICAST_ADDR, NULL, source_addr, UV_JOIN_GROUP); - ASSERT_OK(r); + ASSERT(r == 0); #endif r = do_send(&req_ss); - ASSERT_OK(r); + ASSERT(r == 0); } } TEST_IMPL(udp_multicast_join) { -#if defined(__OpenBSD__) - RETURN_SKIP("Test does not currently work in OpenBSD"); -#endif int r; struct sockaddr_in addr; - ASSERT_OK(uv_ip4_addr("0.0.0.0", TEST_PORT, &addr)); + ASSERT(0 == uv_ip4_addr("0.0.0.0", TEST_PORT, &addr)); r = uv_udp_init(uv_default_loop(), &server); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_udp_init(uv_default_loop(), &client); - ASSERT_OK(r); + ASSERT(r == 0); /* bind to the desired port */ r = uv_udp_bind(&server, (const struct sockaddr*) &addr, 0); - ASSERT_OK(r); + ASSERT(r == 0); /* join the multicast channel */ r = uv_udp_set_membership(&server, MULTICAST_ADDR, NULL, UV_JOIN_GROUP); if (r == UV_ENODEV) RETURN_SKIP("No multicast support."); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_udp_recv_start(&server, alloc_cb, cl_recv_cb); - ASSERT_OK(r); + ASSERT(r == 0); r = do_send(&req); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_OK(close_cb_called); - ASSERT_OK(cl_recv_cb_called); - ASSERT_OK(sv_send_cb_called); + ASSERT(close_cb_called == 0); + ASSERT(cl_recv_cb_called == 0); + ASSERT(sv_send_cb_called == 0); /* run the loop till all events are processed */ uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_EQ(2, cl_recv_cb_called); - ASSERT_EQ(2, sv_send_cb_called); - ASSERT_EQ(2, close_cb_called); + ASSERT(cl_recv_cb_called == 2); + ASSERT(sv_send_cb_called == 2); + ASSERT(close_cb_called == 2); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-udp-multicast-join6.c b/test/test-udp-multicast-join6.c index 11efb0a..e67c5ee 100644 --- a/test/test-udp-multicast-join6.c +++ b/test/test-udp-multicast-join6.c @@ -28,11 +28,12 @@ #define CHECK_HANDLE(handle) \ - ASSERT_NE((uv_udp_t*)(handle) == &server || (uv_udp_t*)(handle) == &client, 0) + ASSERT((uv_udp_t*)(handle) == &server || (uv_udp_t*)(handle) == &client) #if defined(__APPLE__) || \ defined(_AIX) || \ defined(__MVS__) || \ + defined(__FreeBSD_kernel__) || \ defined(__NetBSD__) || \ defined(__OpenBSD__) #define MULTICAST_ADDR "ff02::1%lo0" @@ -58,7 +59,7 @@ static void alloc_cb(uv_handle_t* handle, uv_buf_t* buf) { static char slab[65536]; CHECK_HANDLE(handle); - ASSERT_LE(suggested_size, sizeof(slab)); + ASSERT(suggested_size <= sizeof(slab)); buf->base = slab; buf->len = sizeof(slab); } @@ -72,7 +73,7 @@ static void close_cb(uv_handle_t* handle) { static void sv_send_cb(uv_udp_send_t* req, int status) { ASSERT_NOT_NULL(req); - ASSERT_OK(status); + ASSERT(status == 0); CHECK_HANDLE(req->handle); sv_send_cb_called++; @@ -88,7 +89,7 @@ static int do_send(uv_udp_send_t* send_req) { buf = uv_buf_init("PING", 4); - ASSERT_OK(uv_ip6_addr(MULTICAST_ADDR, TEST_PORT, &addr)); + ASSERT(0 == uv_ip6_addr(MULTICAST_ADDR, TEST_PORT, &addr)); /* client sends "PING" */ return uv_udp_send(send_req, @@ -106,7 +107,7 @@ static void cl_recv_cb(uv_udp_t* handle, const struct sockaddr* addr, unsigned flags) { CHECK_HANDLE(handle); - ASSERT_OK(flags); + ASSERT(flags == 0); if (nread < 0) { ASSERT(0 && "unexpected error"); @@ -119,7 +120,7 @@ static void cl_recv_cb(uv_udp_t* handle, } ASSERT_NOT_NULL(addr); - ASSERT_EQ(4, nread); + ASSERT(nread == 4); ASSERT(!memcmp("PING", buf->base, nread)); cl_recv_cb_called++; @@ -132,16 +133,16 @@ static void cl_recv_cb(uv_udp_t* handle, char source_addr[64]; r = uv_ip6_name((const struct sockaddr_in6*)addr, source_addr, sizeof(source_addr)); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_udp_set_membership(&server, MULTICAST_ADDR, INTERFACE_ADDR, UV_LEAVE_GROUP); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_udp_set_source_membership(&server, MULTICAST_ADDR, INTERFACE_ADDR, source_addr, UV_JOIN_GROUP); - ASSERT_OK(r); + ASSERT(r == 0); r = do_send(&req_ss); - ASSERT_OK(r); + ASSERT(r == 0); } } @@ -172,47 +173,47 @@ TEST_IMPL(udp_multicast_join6) { if (!can_ipv6_external()) RETURN_SKIP("No external IPv6 interface available"); - ASSERT_OK(uv_ip6_addr("::", TEST_PORT, &addr)); + ASSERT(0 == uv_ip6_addr("::", TEST_PORT, &addr)); r = uv_udp_init(uv_default_loop(), &server); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_udp_init(uv_default_loop(), &client); - ASSERT_OK(r); + ASSERT(r == 0); /* bind to the desired port */ r = uv_udp_bind(&server, (const struct sockaddr*) &addr, 0); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_udp_set_membership(&server, MULTICAST_ADDR, INTERFACE_ADDR, UV_JOIN_GROUP); if (r == UV_ENODEV) { - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); RETURN_SKIP("No ipv6 multicast route"); } - ASSERT_OK(r); + ASSERT(r == 0); /* TODO(gengjiawen): Fix test on QEMU. */ #if defined(__QEMU__) RETURN_SKIP("Test does not currently work in QEMU"); #endif r = uv_udp_recv_start(&server, alloc_cb, cl_recv_cb); - ASSERT_OK(r); + ASSERT(r == 0); r = do_send(&req); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_OK(close_cb_called); - ASSERT_OK(cl_recv_cb_called); - ASSERT_OK(sv_send_cb_called); + ASSERT(close_cb_called == 0); + ASSERT(cl_recv_cb_called == 0); + ASSERT(sv_send_cb_called == 0); /* run the loop till all events are processed */ uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_EQ(2, cl_recv_cb_called); - ASSERT_EQ(2, sv_send_cb_called); - ASSERT_EQ(2, close_cb_called); + ASSERT(cl_recv_cb_called == 2); + ASSERT(sv_send_cb_called == 2); + ASSERT(close_cb_called == 2); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-udp-multicast-ttl.c b/test/test-udp-multicast-ttl.c index 50bc54a..fbddd90 100644 --- a/test/test-udp-multicast-ttl.c +++ b/test/test-udp-multicast-ttl.c @@ -27,7 +27,7 @@ #include #define CHECK_HANDLE(handle) \ - ASSERT_NE((uv_udp_t*)(handle) == &server || (uv_udp_t*)(handle) == &client, 0) + ASSERT((uv_udp_t*)(handle) == &server || (uv_udp_t*)(handle) == &client) static uv_udp_t server; static uv_udp_t client; @@ -60,35 +60,35 @@ TEST_IMPL(udp_multicast_ttl) { struct sockaddr_in addr; r = uv_udp_init(uv_default_loop(), &server); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_OK(uv_ip4_addr("0.0.0.0", 0, &addr)); + ASSERT(0 == uv_ip4_addr("0.0.0.0", 0, &addr)); r = uv_udp_bind(&server, (const struct sockaddr*) &addr, 0); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_udp_set_multicast_ttl(&server, 32); - ASSERT_OK(r); + ASSERT(r == 0); /* server sends "PING" */ buf = uv_buf_init("PING", 4); - ASSERT_OK(uv_ip4_addr("239.255.0.1", TEST_PORT, &addr)); + ASSERT(0 == uv_ip4_addr("239.255.0.1", TEST_PORT, &addr)); r = uv_udp_send(&req, &server, &buf, 1, (const struct sockaddr*) &addr, sv_send_cb); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_OK(close_cb_called); - ASSERT_OK(sv_send_cb_called); + ASSERT(close_cb_called == 0); + ASSERT(sv_send_cb_called == 0); /* run the loop till all events are processed */ uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_EQ(1, sv_send_cb_called); - ASSERT_EQ(1, close_cb_called); + ASSERT(sv_send_cb_called == 1); + ASSERT(close_cb_called == 1); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-udp-open.c b/test/test-udp-open.c index 6fddc93..f5136b6 100644 --- a/test/test-udp-open.c +++ b/test/test-udp-open.c @@ -41,7 +41,7 @@ static void startup(void) { #ifdef _WIN32 struct WSAData wsa_data; int r = WSAStartup(MAKEWORD(2, 2), &wsa_data); - ASSERT_OK(r); + ASSERT(r == 0); #endif } @@ -51,9 +51,9 @@ static uv_os_sock_t create_udp_socket(void) { sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_IP); #ifdef _WIN32 - ASSERT_NE(sock, INVALID_SOCKET); + ASSERT(sock != INVALID_SOCKET); #else - ASSERT_GE(sock, 0); + ASSERT(sock >= 0); #endif #ifndef _WIN32 @@ -61,7 +61,7 @@ static uv_os_sock_t create_udp_socket(void) { /* Allow reuse of the port. */ int yes = 1; int r = setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof yes); - ASSERT_OK(r); + ASSERT(r == 0); } #endif @@ -76,7 +76,7 @@ static void close_socket(uv_os_sock_t sock) { #else r = close(sock); #endif - ASSERT_OK(r); + ASSERT(r == 0); } @@ -84,7 +84,7 @@ static void alloc_cb(uv_handle_t* handle, size_t suggested_size, uv_buf_t* buf) { static char slab[65536]; - ASSERT_LE(suggested_size, sizeof(slab)); + ASSERT(suggested_size <= sizeof(slab)); buf->base = slab; buf->len = sizeof(slab); } @@ -113,14 +113,14 @@ static void recv_cb(uv_udp_t* handle, return; } - ASSERT_OK(flags); + ASSERT(flags == 0); ASSERT_NOT_NULL(addr); - ASSERT_EQ(4, nread); - ASSERT_OK(memcmp("PING", buf->base, nread)); + ASSERT(nread == 4); + ASSERT(memcmp("PING", buf->base, nread) == 0); r = uv_udp_recv_stop(handle); - ASSERT_OK(r); + ASSERT(r == 0); uv_close((uv_handle_t*) handle, close_cb); } @@ -128,7 +128,7 @@ static void recv_cb(uv_udp_t* handle, static void send_cb(uv_udp_send_t* req, int status) { ASSERT_NOT_NULL(req); - ASSERT_OK(status); + ASSERT(status == 0); send_cb_called++; uv_close((uv_handle_t*)req->handle, close_cb); @@ -142,22 +142,22 @@ TEST_IMPL(udp_open) { uv_os_sock_t sock; int r; - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); + ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); startup(); sock = create_udp_socket(); r = uv_udp_init(uv_default_loop(), &client); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_udp_open(&client, sock); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_udp_bind(&client, (const struct sockaddr*) &addr, 0); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_udp_recv_start(&client, alloc_cb, recv_cb); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_udp_send(&send_req, &client, @@ -165,15 +165,15 @@ TEST_IMPL(udp_open) { 1, (const struct sockaddr*) &addr, send_cb); - ASSERT_OK(r); + ASSERT(r == 0); #ifndef _WIN32 { r = uv_udp_init(uv_default_loop(), &client2); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_udp_open(&client2, sock); - ASSERT_EQ(r, UV_EEXIST); + ASSERT(r == UV_EEXIST); uv_close((uv_handle_t*) &client2, NULL); } @@ -183,12 +183,12 @@ TEST_IMPL(udp_open) { uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_EQ(1, send_cb_called); - ASSERT_EQ(1, close_cb_called); + ASSERT(send_cb_called == 1); + ASSERT(close_cb_called == 1); - ASSERT_OK(client.send_queue_size); + ASSERT(client.send_queue_size == 0); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -203,19 +203,19 @@ TEST_IMPL(udp_open_twice) { sock2 = create_udp_socket(); r = uv_udp_init(uv_default_loop(), &client); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_udp_open(&client, sock1); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_udp_open(&client, sock2); - ASSERT_EQ(r, UV_EBUSY); + ASSERT(r == UV_EBUSY); close_socket(sock2); uv_close((uv_handle_t*) &client, NULL); uv_run(uv_default_loop(), UV_RUN_DEFAULT); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -225,27 +225,27 @@ TEST_IMPL(udp_open_bound) { uv_os_sock_t sock; int r; - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); + ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); startup(); sock = create_udp_socket(); r = bind(sock, (struct sockaddr*) &addr, sizeof(addr)); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_udp_init(uv_default_loop(), &client); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_udp_open(&client, sock); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_udp_recv_start(&client, alloc_cb, recv_cb); - ASSERT_OK(r); + ASSERT(r == 0); uv_close((uv_handle_t*) &client, NULL); uv_run(uv_default_loop(), UV_RUN_DEFAULT); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -257,28 +257,28 @@ TEST_IMPL(udp_open_connect) { uv_os_sock_t sock; int r; - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); + ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); startup(); sock = create_udp_socket(); r = uv_udp_init(uv_default_loop(), &client); - ASSERT_OK(r); + ASSERT(r == 0); r = connect(sock, (const struct sockaddr*) &addr, sizeof(addr)); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_udp_open(&client, sock); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_udp_init(uv_default_loop(), &server); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_udp_bind(&server, (const struct sockaddr*) &addr, 0); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_udp_recv_start(&server, alloc_cb, recv_cb); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_udp_send(&send_req, &client, @@ -286,16 +286,16 @@ TEST_IMPL(udp_open_connect) { 1, NULL, send_cb); - ASSERT_OK(r); + ASSERT(r == 0); uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_EQ(1, send_cb_called); - ASSERT_EQ(2, close_cb_called); + ASSERT(send_cb_called == 1); + ASSERT(close_cb_called == 2); - ASSERT_OK(client.send_queue_size); + ASSERT(client.send_queue_size == 0); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -315,20 +315,20 @@ TEST_IMPL(udp_send_unix) { memset(&addr, 0, sizeof addr); addr.sun_family = AF_UNIX; - ASSERT_LT(strlen(TEST_PIPENAME), sizeof(addr.sun_path)); + ASSERT(strlen(TEST_PIPENAME) < sizeof(addr.sun_path)); memcpy(addr.sun_path, TEST_PIPENAME, strlen(TEST_PIPENAME)); fd = socket(AF_UNIX, SOCK_STREAM, 0); - ASSERT_GE(fd, 0); + ASSERT(fd >= 0); unlink(TEST_PIPENAME); - ASSERT_OK(bind(fd, (const struct sockaddr*)&addr, sizeof addr)); - ASSERT_OK(listen(fd, 1)); + ASSERT(0 == bind(fd, (const struct sockaddr*)&addr, sizeof addr)); + ASSERT(0 == listen(fd, 1)); r = uv_udp_init(loop, &handle); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_udp_open(&handle, fd); - ASSERT_OK(r); + ASSERT(r == 0); uv_run(loop, UV_RUN_DEFAULT); r = uv_udp_send(&req, @@ -337,14 +337,14 @@ TEST_IMPL(udp_send_unix) { 1, (const struct sockaddr*) &addr, NULL); - ASSERT_OK(r); + ASSERT(r == 0); uv_close((uv_handle_t*)&handle, NULL); uv_run(loop, UV_RUN_DEFAULT); close(fd); unlink(TEST_PIPENAME); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } #endif diff --git a/test/test-udp-options.c b/test/test-udp-options.c index bb4a24c..3ea51ba 100644 --- a/test/test-udp-options.c +++ b/test/test-udp-options.c @@ -36,58 +36,58 @@ static int udp_options_test(const struct sockaddr* addr) { loop = uv_default_loop(); r = uv_udp_init(loop, &h); - ASSERT_OK(r); + ASSERT(r == 0); uv_unref((uv_handle_t*)&h); /* don't keep the loop alive */ r = uv_udp_bind(&h, addr, 0); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_udp_set_broadcast(&h, 1); r |= uv_udp_set_broadcast(&h, 1); r |= uv_udp_set_broadcast(&h, 0); r |= uv_udp_set_broadcast(&h, 0); - ASSERT_OK(r); + ASSERT(r == 0); /* values 1-255 should work */ for (i = 1; i <= 255; i++) { r = uv_udp_set_ttl(&h, i); #if defined(__MVS__) if (addr->sa_family == AF_INET6) - ASSERT_OK(r); + ASSERT(r == 0); else - ASSERT_EQ(r, UV_ENOTSUP); + ASSERT(r == UV_ENOTSUP); #else - ASSERT_OK(r); + ASSERT(r == 0); #endif } for (i = 0; i < (int) ARRAY_SIZE(invalid_ttls); i++) { r = uv_udp_set_ttl(&h, invalid_ttls[i]); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); } r = uv_udp_set_multicast_loop(&h, 1); r |= uv_udp_set_multicast_loop(&h, 1); r |= uv_udp_set_multicast_loop(&h, 0); r |= uv_udp_set_multicast_loop(&h, 0); - ASSERT_OK(r); + ASSERT(r == 0); /* values 0-255 should work */ for (i = 0; i <= 255; i++) { r = uv_udp_set_multicast_ttl(&h, i); - ASSERT_OK(r); + ASSERT(r == 0); } /* anything >255 should fail */ r = uv_udp_set_multicast_ttl(&h, 256); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); /* don't test ttl=-1, it's a valid value on some platforms */ r = uv_run(loop, UV_RUN_DEFAULT); - ASSERT_OK(r); + ASSERT(r == 0); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } @@ -95,7 +95,7 @@ static int udp_options_test(const struct sockaddr* addr) { TEST_IMPL(udp_options) { struct sockaddr_in addr; - ASSERT_OK(uv_ip4_addr("0.0.0.0", TEST_PORT, &addr)); + ASSERT(0 == uv_ip4_addr("0.0.0.0", TEST_PORT, &addr)); return udp_options_test((const struct sockaddr*) &addr); } @@ -106,7 +106,7 @@ TEST_IMPL(udp_options6) { if (!can_ipv6()) RETURN_SKIP("IPv6 not supported"); - ASSERT_OK(uv_ip6_addr("::", TEST_PORT, &addr)); + ASSERT(0 == uv_ip6_addr("::", TEST_PORT, &addr)); return udp_options_test((const struct sockaddr*) &addr); } @@ -119,42 +119,42 @@ TEST_IMPL(udp_no_autobind) { loop = uv_default_loop(); /* Test a lazy initialized socket. */ - ASSERT_OK(uv_udp_init(loop, &h)); - ASSERT_EQ(UV_EBADF, uv_udp_set_multicast_ttl(&h, 32)); - ASSERT_EQ(UV_EBADF, uv_udp_set_broadcast(&h, 1)); + ASSERT(0 == uv_udp_init(loop, &h)); + ASSERT(UV_EBADF == uv_udp_set_multicast_ttl(&h, 32)); + ASSERT(UV_EBADF == uv_udp_set_broadcast(&h, 1)); #if defined(__MVS__) - ASSERT_EQ(UV_ENOTSUP, uv_udp_set_ttl(&h, 1)); + ASSERT(UV_ENOTSUP == uv_udp_set_ttl(&h, 1)); #else - ASSERT_EQ(UV_EBADF, uv_udp_set_ttl(&h, 1)); + ASSERT(UV_EBADF == uv_udp_set_ttl(&h, 1)); #endif - ASSERT_EQ(UV_EBADF, uv_udp_set_multicast_loop(&h, 1)); + ASSERT(UV_EBADF == uv_udp_set_multicast_loop(&h, 1)); /* TODO(gengjiawen): Fix test on QEMU. */ #if defined(__QEMU__) RETURN_SKIP("Test does not currently work in QEMU"); #endif - ASSERT_EQ(UV_EBADF, uv_udp_set_multicast_interface(&h, "0.0.0.0")); + ASSERT(UV_EBADF == uv_udp_set_multicast_interface(&h, "0.0.0.0")); uv_close((uv_handle_t*) &h, NULL); /* Test a non-lazily initialized socket. */ - ASSERT_OK(uv_udp_init_ex(loop, &h2, AF_INET | UV_UDP_RECVMMSG)); - ASSERT_OK(uv_udp_set_multicast_ttl(&h2, 32)); - ASSERT_OK(uv_udp_set_broadcast(&h2, 1)); + ASSERT(0 == uv_udp_init_ex(loop, &h2, AF_INET | UV_UDP_RECVMMSG)); + ASSERT(0 == uv_udp_set_multicast_ttl(&h2, 32)); + ASSERT(0 == uv_udp_set_broadcast(&h2, 1)); #if defined(__MVS__) /* zOS only supports setting ttl for IPv6 sockets. */ - ASSERT_EQ(UV_ENOTSUP, uv_udp_set_ttl(&h2, 1)); + ASSERT(UV_ENOTSUP == uv_udp_set_ttl(&h2, 1)); #else - ASSERT_OK(uv_udp_set_ttl(&h2, 1)); + ASSERT(0 == uv_udp_set_ttl(&h2, 1)); #endif - ASSERT_OK(uv_udp_set_multicast_loop(&h2, 1)); - ASSERT_OK(uv_udp_set_multicast_interface(&h2, "0.0.0.0")); + ASSERT(0 == uv_udp_set_multicast_loop(&h2, 1)); + ASSERT(0 == uv_udp_set_multicast_interface(&h2, "0.0.0.0")); uv_close((uv_handle_t*) &h2, NULL); - ASSERT_OK(uv_run(loop, UV_RUN_DEFAULT)); + ASSERT(0 == uv_run(loop, UV_RUN_DEFAULT)); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-udp-recv-in-a-row.c b/test/test-udp-recv-in-a-row.c deleted file mode 100644 index 30745de..0000000 --- a/test/test-udp-recv-in-a-row.c +++ /dev/null @@ -1,121 +0,0 @@ -/* Copyright The libuv project and contributors. All rights reserved. - * - * Permission is hereby granted, free of charge, to any person obtaining a copy - * of this software and associated documentation files (the "Software"), to - * deal in the Software without restriction, including without limitation the - * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or - * sell copies of the Software, and to permit persons to whom the Software is - * furnished to do so, subject to the following conditions: - * - * The above copyright notice and this permission notice shall be included in - * all copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING - * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS - * IN THE SOFTWARE. - */ - -#include "uv.h" -#include "task.h" - -#include -#include -#include - -static uv_udp_t server; -static uv_udp_t client; -static uv_check_t check_handle; -static uv_buf_t buf; -static struct sockaddr_in addr; -static char send_data[10]; -static int check_cb_called; - -#define N 5 -static int recv_cnt; - -static void alloc_cb(uv_handle_t* handle, - size_t suggested_size, - uv_buf_t* buf) { - static char slab[sizeof(send_data)]; - buf->base = slab; - buf->len = sizeof(slab); -} - -static void sv_recv_cb(uv_udp_t* handle, - ssize_t nread, - const uv_buf_t* rcvbuf, - const struct sockaddr* addr, - unsigned flags) { - if (++ recv_cnt < N) { - ASSERT_EQ(sizeof(send_data), nread); - } else { - ASSERT_OK(nread); - } -} - -static void check_cb(uv_check_t* handle) { - ASSERT_PTR_EQ(&check_handle, handle); - - /** - * sv_recv_cb() is called with nread set to zero to indicate - * there is no more udp packet in the kernel, so the actual - * recv_cnt is one larger than N. - */ - ASSERT_EQ(N+1, recv_cnt); - check_cb_called = 1; - - /* we are done */ - ASSERT_OK(uv_check_stop(handle)); - uv_close((uv_handle_t*) &client, NULL); - uv_close((uv_handle_t*) &check_handle, NULL); - uv_close((uv_handle_t*) &server, NULL); -} - - -TEST_IMPL(udp_recv_in_a_row) { - int i, r; - - ASSERT_OK(uv_check_init(uv_default_loop(), &check_handle)); - ASSERT_OK(uv_check_start(&check_handle, check_cb)); - - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); - - ASSERT_OK(uv_udp_init(uv_default_loop(), &server)); - ASSERT_OK(uv_udp_bind(&server, (const struct sockaddr*) &addr, 0)); - ASSERT_OK(uv_udp_recv_start(&server, alloc_cb, sv_recv_cb)); - - ASSERT_OK(uv_udp_init(uv_default_loop(), &client)); - - /* send N-1 udp packets */ - buf = uv_buf_init(send_data, sizeof(send_data)); - for (i = 0; i < N - 1; i ++) { - r = uv_udp_try_send(&client, - &buf, - 1, - (const struct sockaddr*) &addr); - ASSERT_EQ(sizeof(send_data), r); - } - - /* send an empty udp packet */ - buf = uv_buf_init(NULL, 0); - r = uv_udp_try_send(&client, - &buf, - 1, - (const struct sockaddr*) &addr); - ASSERT_OK(r); - - /* check_cb() asserts that the N packets can be received - * before it gets called. - */ - - ASSERT_OK(uv_run(uv_default_loop(), UV_RUN_DEFAULT)); - - ASSERT(check_cb_called); - - MAKE_VALGRIND_HAPPY(uv_default_loop()); - return 0; -} diff --git a/test/test-udp-send-and-recv.c b/test/test-udp-send-and-recv.c index b24fe1d..d602090 100644 --- a/test/test-udp-send-and-recv.c +++ b/test/test-udp-send-and-recv.c @@ -27,7 +27,7 @@ #include #define CHECK_HANDLE(handle) \ - ASSERT_NE((uv_udp_t*)(handle) == &server || (uv_udp_t*)(handle) == &client, 0) + ASSERT((uv_udp_t*)(handle) == &server || (uv_udp_t*)(handle) == &client) static uv_udp_t server; static uv_udp_t client; @@ -46,7 +46,7 @@ static void alloc_cb(uv_handle_t* handle, uv_buf_t* buf) { static char slab[65536]; CHECK_HANDLE(handle); - ASSERT_LE(suggested_size, sizeof(slab)); + ASSERT(suggested_size <= sizeof(slab)); buf->base = slab; buf->len = sizeof(slab); } @@ -54,7 +54,7 @@ static void alloc_cb(uv_handle_t* handle, static void close_cb(uv_handle_t* handle) { CHECK_HANDLE(handle); - ASSERT_EQ(1, uv_is_closing(handle)); + ASSERT(1 == uv_is_closing(handle)); close_cb_called++; } @@ -65,7 +65,7 @@ static void cl_recv_cb(uv_udp_t* handle, const struct sockaddr* addr, unsigned flags) { CHECK_HANDLE(handle); - ASSERT_OK(flags); + ASSERT(flags == 0); if (nread < 0) { ASSERT(0 && "unexpected error"); @@ -78,7 +78,7 @@ static void cl_recv_cb(uv_udp_t* handle, } ASSERT_NOT_NULL(addr); - ASSERT_EQ(4, nread); + ASSERT(nread == 4); ASSERT(!memcmp("PONG", buf->base, nread)); cl_recv_cb_called++; @@ -91,11 +91,11 @@ static void cl_send_cb(uv_udp_send_t* req, int status) { int r; ASSERT_NOT_NULL(req); - ASSERT_OK(status); + ASSERT(status == 0); CHECK_HANDLE(req->handle); r = uv_udp_recv_start(req->handle, alloc_cb, cl_recv_cb); - ASSERT_OK(r); + ASSERT(r == 0); cl_send_cb_called++; } @@ -103,7 +103,7 @@ static void cl_send_cb(uv_udp_send_t* req, int status) { static void sv_send_cb(uv_udp_send_t* req, int status) { ASSERT_NOT_NULL(req); - ASSERT_OK(status); + ASSERT(status == 0); CHECK_HANDLE(req->handle); uv_close((uv_handle_t*) req->handle, close_cb); @@ -133,10 +133,10 @@ static void sv_recv_cb(uv_udp_t* handle, } CHECK_HANDLE(handle); - ASSERT_OK(flags); + ASSERT(flags == 0); ASSERT_NOT_NULL(addr); - ASSERT_EQ(4, nread); + ASSERT(nread == 4); ASSERT(!memcmp("PING", rcvbuf->base, nread)); /* FIXME? `uv_udp_recv_stop` does what it says: recv_cb is not called @@ -144,14 +144,14 @@ static void sv_recv_cb(uv_udp_t* handle, * either... Not sure I like that but it's consistent with `uv_read_stop`. */ r = uv_udp_recv_stop(handle); - ASSERT_OK(r); + ASSERT(r == 0); req = malloc(sizeof *req); ASSERT_NOT_NULL(req); sndbuf = uv_buf_init("PONG", 4); r = uv_udp_send(req, handle, &sndbuf, 1, addr, sv_send_cb); - ASSERT_OK(r); + ASSERT(r == 0); sv_recv_cb_called++; } @@ -163,21 +163,21 @@ TEST_IMPL(udp_send_and_recv) { uv_buf_t buf; int r; - ASSERT_OK(uv_ip4_addr("0.0.0.0", TEST_PORT, &addr)); + ASSERT(0 == uv_ip4_addr("0.0.0.0", TEST_PORT, &addr)); r = uv_udp_init(uv_default_loop(), &server); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_udp_bind(&server, (const struct sockaddr*) &addr, 0); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_udp_recv_start(&server, alloc_cb, sv_recv_cb); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); + ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); r = uv_udp_init(uv_default_loop(), &client); - ASSERT_OK(r); + ASSERT(r == 0); /* client sends "PING", expects "PONG" */ buf = uv_buf_init("PING", 4); @@ -188,25 +188,25 @@ TEST_IMPL(udp_send_and_recv) { 1, (const struct sockaddr*) &addr, cl_send_cb); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_OK(close_cb_called); - ASSERT_OK(cl_send_cb_called); - ASSERT_OK(cl_recv_cb_called); - ASSERT_OK(sv_send_cb_called); - ASSERT_OK(sv_recv_cb_called); + ASSERT(close_cb_called == 0); + ASSERT(cl_send_cb_called == 0); + ASSERT(cl_recv_cb_called == 0); + ASSERT(sv_send_cb_called == 0); + ASSERT(sv_recv_cb_called == 0); uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_EQ(1, cl_send_cb_called); - ASSERT_EQ(1, cl_recv_cb_called); - ASSERT_EQ(1, sv_send_cb_called); - ASSERT_EQ(1, sv_recv_cb_called); - ASSERT_EQ(2, close_cb_called); + ASSERT(cl_send_cb_called == 1); + ASSERT(cl_recv_cb_called == 1); + ASSERT(sv_send_cb_called == 1); + ASSERT(sv_recv_cb_called == 1); + ASSERT(close_cb_called == 2); - ASSERT_OK(client.send_queue_size); - ASSERT_OK(server.send_queue_size); + ASSERT(client.send_queue_size == 0); + ASSERT(server.send_queue_size == 0); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-udp-send-hang-loop.c b/test/test-udp-send-hang-loop.c index 763bb28..072070b 100644 --- a/test/test-udp-send-hang-loop.c +++ b/test/test-udp-send-hang-loop.c @@ -27,7 +27,7 @@ #include #define CHECK_OBJECT(handle, type, parent) \ - ASSERT_PTR_EQ((type*)(handle), &(parent)) + ASSERT((type*)(handle) == &(parent)) static uv_udp_t client; static uv_idle_t idle_handle; @@ -46,7 +46,7 @@ static void idle_cb(uv_idle_t* handle) { ASSERT_NULL(send_req.handle); CHECK_OBJECT(handle, uv_idle_t, idle_handle); - ASSERT_OK(uv_idle_stop(handle)); + ASSERT(0 == uv_idle_stop(handle)); /* It probably would have stalled by now if it's going to stall at all. */ if (++loop_hang_called > 1000) { @@ -61,7 +61,7 @@ static void idle_cb(uv_idle_t* handle) { 1, (const struct sockaddr*) &addr, send_cb); - ASSERT_OK(r); + ASSERT(r == 0); } @@ -72,28 +72,28 @@ static void send_cb(uv_udp_send_t* req, int status) { CHECK_OBJECT(req, uv_udp_send_t, send_req); req->handle = NULL; - ASSERT_OK(uv_idle_start(&idle_handle, idle_cb)); + ASSERT(0 == uv_idle_start(&idle_handle, idle_cb)); } TEST_IMPL(udp_send_hang_loop) { - ASSERT_OK(uv_idle_init(uv_default_loop(), &idle_handle)); + ASSERT(0 == uv_idle_init(uv_default_loop(), &idle_handle)); - /* 192.0.2.0/24 is "TEST-NET" and reserved for documentation. + /* 192.0.2.0/8 is "TEST-NET" and reserved for documentation. * Good for us, though. Since we want to have something unreachable. */ - ASSERT_OK(uv_ip4_addr("192.0.2.3", TEST_PORT, &addr)); + ASSERT(0 == uv_ip4_addr("192.0.2.3", TEST_PORT, &addr)); - ASSERT_OK(uv_udp_init(uv_default_loop(), &client)); + ASSERT(0 == uv_udp_init(uv_default_loop(), &client)); buf = uv_buf_init(send_data, sizeof(send_data)); - ASSERT_OK(uv_idle_start(&idle_handle, idle_cb)); + ASSERT(0 == uv_idle_start(&idle_handle, idle_cb)); uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_GT(loop_hang_called, 1000); + ASSERT(loop_hang_called > 1000); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-udp-send-immediate.c b/test/test-udp-send-immediate.c index 8e7f83f..a1c95d3 100644 --- a/test/test-udp-send-immediate.c +++ b/test/test-udp-send-immediate.c @@ -27,7 +27,7 @@ #include #define CHECK_HANDLE(handle) \ - ASSERT_NE((uv_udp_t*)(handle) == &server || (uv_udp_t*)(handle) == &client, 0) + ASSERT((uv_udp_t*)(handle) == &server || (uv_udp_t*)(handle) == &client) static uv_udp_t server; static uv_udp_t client; @@ -42,7 +42,7 @@ static void alloc_cb(uv_handle_t* handle, uv_buf_t* buf) { static char slab[65536]; CHECK_HANDLE(handle); - ASSERT_LE(suggested_size, sizeof(slab)); + ASSERT(suggested_size <= sizeof(slab)); buf->base = slab; buf->len = sizeof(slab); } @@ -50,14 +50,14 @@ static void alloc_cb(uv_handle_t* handle, static void close_cb(uv_handle_t* handle) { CHECK_HANDLE(handle); - ASSERT_EQ(1, uv_is_closing(handle)); + ASSERT(1 == uv_is_closing(handle)); close_cb_called++; } static void cl_send_cb(uv_udp_send_t* req, int status) { ASSERT_NOT_NULL(req); - ASSERT_OK(status); + ASSERT(status == 0); CHECK_HANDLE(req->handle); cl_send_cb_called++; @@ -80,10 +80,10 @@ static void sv_recv_cb(uv_udp_t* handle, } CHECK_HANDLE(handle); - ASSERT_OK(flags); + ASSERT(flags == 0); ASSERT_NOT_NULL(addr); - ASSERT_EQ(4, nread); + ASSERT(nread == 4); ASSERT(memcmp("PING", rcvbuf->base, nread) == 0 || memcmp("PANG", rcvbuf->base, nread) == 0); @@ -100,21 +100,21 @@ TEST_IMPL(udp_send_immediate) { uv_buf_t buf; int r; - ASSERT_OK(uv_ip4_addr("0.0.0.0", TEST_PORT, &addr)); + ASSERT(0 == uv_ip4_addr("0.0.0.0", TEST_PORT, &addr)); r = uv_udp_init(uv_default_loop(), &server); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_udp_bind(&server, (const struct sockaddr*) &addr, 0); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_udp_recv_start(&server, alloc_cb, sv_recv_cb); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); + ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); r = uv_udp_init(uv_default_loop(), &client); - ASSERT_OK(r); + ASSERT(r == 0); /* client sends "PING", then "PANG" */ buf = uv_buf_init("PING", 4); @@ -125,7 +125,7 @@ TEST_IMPL(udp_send_immediate) { 1, (const struct sockaddr*) &addr, cl_send_cb); - ASSERT_OK(r); + ASSERT(r == 0); buf = uv_buf_init("PANG", 4); @@ -135,14 +135,14 @@ TEST_IMPL(udp_send_immediate) { 1, (const struct sockaddr*) &addr, cl_send_cb); - ASSERT_OK(r); + ASSERT(r == 0); uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_EQ(2, cl_send_cb_called); - ASSERT_EQ(2, sv_recv_cb_called); - ASSERT_EQ(2, close_cb_called); + ASSERT(cl_send_cb_called == 2); + ASSERT(sv_recv_cb_called == 2); + ASSERT(close_cb_called == 2); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-udp-send-unreachable.c b/test/test-udp-send-unreachable.c index 0a2f4a4..c67a23b 100644 --- a/test/test-udp-send-unreachable.c +++ b/test/test-udp-send-unreachable.c @@ -27,7 +27,7 @@ #include #define CHECK_HANDLE(handle) \ - ASSERT_NE((uv_udp_t*)(handle) == &client || (uv_udp_t*)(handle) == &client2, 0) + ASSERT((uv_udp_t*)(handle) == &client || (uv_udp_t*)(handle) == &client2) static uv_udp_t client; static uv_udp_t client2; @@ -61,8 +61,8 @@ static void close_cb(uv_handle_t* handle) { static void send_cb(uv_udp_send_t* req, int status) { ASSERT_NOT_NULL(req); - ASSERT_OK(status); - ASSERT_OK(status); + ASSERT(status == 0); + ASSERT_EQ(status, 0); CHECK_HANDLE(req->handle); send_cb_called++; } @@ -115,24 +115,24 @@ TEST_IMPL(udp_send_unreachable) { can_recverr = 1; #endif - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT_2, &addr2)); - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT_3, &addr3)); + ASSERT_EQ(0, uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); + ASSERT_EQ(0, uv_ip4_addr("127.0.0.1", TEST_PORT_2, &addr2)); + ASSERT_EQ(0, uv_ip4_addr("127.0.0.1", TEST_PORT_3, &addr3)); r = uv_timer_init( uv_default_loop(), &timer ); - ASSERT_OK(r); + ASSERT_EQ(r, 0); r = uv_timer_start( &timer, timer_cb, 1000, 0 ); - ASSERT_OK(r); + ASSERT_EQ(r, 0); r = uv_udp_init(uv_default_loop(), &client); - ASSERT_OK(r); + ASSERT_EQ(r, 0); r = uv_udp_bind(&client, (const struct sockaddr*) &addr2, 0); - ASSERT_OK(r); + ASSERT_EQ(r, 0); r = uv_udp_recv_start(&client, alloc_cb, recv_cb); - ASSERT_OK(r); + ASSERT_EQ(r, 0); /* client sends "PING", then "PANG" */ buf = uv_buf_init("PING", 4); @@ -143,7 +143,7 @@ TEST_IMPL(udp_send_unreachable) { 1, (const struct sockaddr*) &addr, send_cb); - ASSERT_OK(r); + ASSERT_EQ(r, 0); buf = uv_buf_init("PANG", 4); @@ -153,19 +153,19 @@ TEST_IMPL(udp_send_unreachable) { 1, (const struct sockaddr*) &addr, send_cb); - ASSERT_OK(r); + ASSERT_EQ(r, 0); if (can_recverr) { r = uv_udp_init(uv_default_loop(), &client2); - ASSERT_OK(r); + ASSERT_EQ(r, 0); r = uv_udp_bind(&client2, (const struct sockaddr*) &addr3, UV_UDP_LINUX_RECVERR); - ASSERT_OK(r); + ASSERT_EQ(r, 0); r = uv_udp_recv_start(&client2, alloc_cb, recv_cb); - ASSERT_OK(r); + ASSERT_EQ(r, 0); /* client sends "PING", then "PANG" */ buf = uv_buf_init("PING", 4); @@ -176,7 +176,7 @@ TEST_IMPL(udp_send_unreachable) { 1, (const struct sockaddr*) &addr, send_cb_recverr); - ASSERT_OK(r); + ASSERT_EQ(r, 0); buf = uv_buf_init("PANG", 4); @@ -186,16 +186,16 @@ TEST_IMPL(udp_send_unreachable) { 1, (const struct sockaddr*) &addr, send_cb_recverr); - ASSERT_OK(r); + ASSERT_EQ(r, 0); } uv_run(uv_default_loop(), UV_RUN_DEFAULT); ASSERT_EQ(send_cb_called, (long)(can_recverr ? 4 : 2)); ASSERT_EQ(recv_cb_called, alloc_cb_called); - ASSERT_EQ(1, timer_cb_called); + ASSERT_EQ(timer_cb_called, 1); ASSERT_EQ(close_cb_called, (long)(can_recverr ? 3 : 2)); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-udp-sendmmsg-error.c b/test/test-udp-sendmmsg-error.c index 0b64758..c8a411b 100644 --- a/test/test-udp-sendmmsg-error.c +++ b/test/test-udp-sendmmsg-error.c @@ -55,21 +55,21 @@ TEST_IMPL(udp_sendmmsg_error) { uv_buf_t buf; int i; - ASSERT_OK(uv_udp_init(uv_default_loop(), &client)); - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); - ASSERT_OK(uv_udp_connect(&client, (const struct sockaddr*)&addr)); + ASSERT_EQ(0, uv_udp_init(uv_default_loop(), &client)); + ASSERT_EQ(0, uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); + ASSERT_EQ(0, uv_udp_connect(&client, (const struct sockaddr*)&addr)); buf = uv_buf_init("TEST", 4); for (i = 0; i < DATAGRAMS; ++i) - ASSERT_OK(uv_udp_send(&req[i], &client, &buf, 1, NULL, send_cb)); + ASSERT_EQ(0, uv_udp_send(&req[i], &client, &buf, 1, NULL, send_cb)); uv_run(uv_default_loop(), UV_RUN_DEFAULT); ASSERT_EQ(1, close_cb_called); ASSERT_EQ(DATAGRAMS, send_cb_called); - ASSERT_OK(client.send_queue_size); + ASSERT_EQ(0, client.send_queue_size); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-udp-try-send.c b/test/test-udp-try-send.c index 0c76fb1..85caaac 100644 --- a/test/test-udp-try-send.c +++ b/test/test-udp-try-send.c @@ -27,7 +27,7 @@ #include #define CHECK_HANDLE(handle) \ - ASSERT_NE((uv_udp_t*)(handle) == &server || (uv_udp_t*)(handle) == &client, 0) + ASSERT((uv_udp_t*)(handle) == &server || (uv_udp_t*)(handle) == &client) static uv_udp_t server; static uv_udp_t client; @@ -42,7 +42,7 @@ static void alloc_cb(uv_handle_t* handle, uv_buf_t* buf) { static char slab[65536]; CHECK_HANDLE(handle); - ASSERT_LE(suggested_size, sizeof(slab)); + ASSERT(suggested_size <= sizeof(slab)); buf->base = slab; buf->len = sizeof(slab); } @@ -60,17 +60,17 @@ static void sv_recv_cb(uv_udp_t* handle, const uv_buf_t* rcvbuf, const struct sockaddr* addr, unsigned flags) { - ASSERT_GT(nread, 0); + ASSERT(nread > 0); if (nread == 0) { ASSERT_NULL(addr); return; } - ASSERT_EQ(4, nread); + ASSERT(nread == 4); ASSERT_NOT_NULL(addr); - ASSERT_OK(memcmp("EXIT", rcvbuf->base, nread)); + ASSERT(memcmp("EXIT", rcvbuf->base, nread) == 0); uv_close((uv_handle_t*) handle, close_cb); uv_close((uv_handle_t*) &client, close_cb); @@ -84,38 +84,38 @@ TEST_IMPL(udp_try_send) { uv_buf_t buf; int r; - ASSERT_OK(uv_ip4_addr("0.0.0.0", TEST_PORT, &addr)); + ASSERT(0 == uv_ip4_addr("0.0.0.0", TEST_PORT, &addr)); r = uv_udp_init(uv_default_loop(), &server); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_udp_bind(&server, (const struct sockaddr*) &addr, 0); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_udp_recv_start(&server, alloc_cb, sv_recv_cb); - ASSERT_OK(r); + ASSERT(r == 0); - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); + ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); r = uv_udp_init(uv_default_loop(), &client); - ASSERT_OK(r); + ASSERT(r == 0); buf = uv_buf_init(buffer, sizeof(buffer)); r = uv_udp_try_send(&client, &buf, 1, (const struct sockaddr*) &addr); - ASSERT_EQ(r, UV_EMSGSIZE); + ASSERT(r == UV_EMSGSIZE); buf = uv_buf_init("EXIT", 4); r = uv_udp_try_send(&client, &buf, 1, (const struct sockaddr*) &addr); - ASSERT_EQ(4, r); + ASSERT(r == 4); uv_run(uv_default_loop(), UV_RUN_DEFAULT); - ASSERT_EQ(2, close_cb_called); - ASSERT_EQ(1, sv_recv_cb_called); + ASSERT(close_cb_called == 2); + ASSERT(sv_recv_cb_called == 1); - ASSERT_OK(client.send_queue_size); - ASSERT_OK(server.send_queue_size); + ASSERT(client.send_queue_size == 0); + ASSERT(server.send_queue_size == 0); - MAKE_VALGRIND_HAPPY(uv_default_loop()); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-uname.c b/test/test-uname.c index a384e9f..105a17f 100644 --- a/test/test-uname.c +++ b/test/test-uname.c @@ -39,28 +39,28 @@ TEST_IMPL(uname) { /* Verify that NULL is handled properly. */ r = uv_os_uname(NULL); - ASSERT_EQ(r, UV_EINVAL); + ASSERT(r == UV_EINVAL); /* Verify the happy path. */ r = uv_os_uname(&buffer); - ASSERT_OK(r); + ASSERT(r == 0); #ifndef _WIN32 - ASSERT_NE(uname(&buf), -1); - ASSERT_OK(strcmp(buffer.sysname, buf.sysname)); - ASSERT_OK(strcmp(buffer.version, buf.version)); + ASSERT(uname(&buf) != -1); + ASSERT(strcmp(buffer.sysname, buf.sysname) == 0); + ASSERT(strcmp(buffer.version, buf.version) == 0); # ifdef _AIX snprintf(temp, sizeof(temp), "%s.%s", buf.version, buf.release); - ASSERT_OK(strcmp(buffer.release, temp)); + ASSERT(strcmp(buffer.release, temp) == 0); # else - ASSERT_OK(strcmp(buffer.release, buf.release)); + ASSERT(strcmp(buffer.release, buf.release) == 0); # endif /* _AIX */ # if defined(_AIX) || defined(__PASE__) - ASSERT_OK(strcmp(buffer.machine, "ppc64")); + ASSERT(strcmp(buffer.machine, "ppc64") == 0); # else - ASSERT_OK(strcmp(buffer.machine, buf.machine)); + ASSERT(strcmp(buffer.machine, buf.machine) == 0); # endif /* defined(_AIX) || defined(__PASE__) */ #endif /* _WIN32 */ diff --git a/test/test-walk-handles.c b/test/test-walk-handles.c index 86fcb04..4b0ca6e 100644 --- a/test/test-walk-handles.c +++ b/test/test-walk-handles.c @@ -31,7 +31,7 @@ static uv_timer_t timer; static void walk_cb(uv_handle_t* handle, void* arg) { - ASSERT_PTR_EQ(arg, (void*)magic_cookie); + ASSERT(arg == (void*)magic_cookie); if (handle == (uv_handle_t*)&timer) { seen_timer_handle++; @@ -42,7 +42,7 @@ static void walk_cb(uv_handle_t* handle, void* arg) { static void timer_cb(uv_timer_t* handle) { - ASSERT_PTR_EQ(handle, &timer); + ASSERT(handle == &timer); uv_walk(handle->loop, walk_cb, magic_cookie); uv_close((uv_handle_t*)handle, NULL); @@ -56,22 +56,22 @@ TEST_IMPL(walk_handles) { loop = uv_default_loop(); r = uv_timer_init(loop, &timer); - ASSERT_OK(r); + ASSERT(r == 0); r = uv_timer_start(&timer, timer_cb, 1, 0); - ASSERT_OK(r); + ASSERT(r == 0); /* Start event loop, expect to see the timer handle in walk_cb. */ - ASSERT_OK(seen_timer_handle); + ASSERT(seen_timer_handle == 0); r = uv_run(loop, UV_RUN_DEFAULT); - ASSERT_OK(r); - ASSERT_EQ(1, seen_timer_handle); + ASSERT(r == 0); + ASSERT(seen_timer_handle == 1); /* Loop is finished, walk_cb should not see our timer handle. */ seen_timer_handle = 0; uv_walk(loop, walk_cb, magic_cookie); - ASSERT_OK(seen_timer_handle); + ASSERT(seen_timer_handle == 0); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/test/test-watcher-cross-stop.c b/test/test-watcher-cross-stop.c index 8f79abb..b26deb8 100644 --- a/test/test-watcher-cross-stop.c +++ b/test/test-watcher-cross-stop.c @@ -76,22 +76,22 @@ TEST_IMPL(watcher_cross_stop) { TEST_FILE_LIMIT(ARRAY_SIZE(sockets) + 32); - ASSERT_OK(uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); + ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr)); memset(big_string, 'A', sizeof(big_string)); buf = uv_buf_init(big_string, sizeof(big_string)); for (i = 0; i < ARRAY_SIZE(sockets); i++) { - ASSERT_OK(uv_udp_init(loop, &sockets[i])); - ASSERT_OK(uv_udp_bind(&sockets[i], - (const struct sockaddr*) &addr, - UV_UDP_REUSEADDR)); - ASSERT_OK(uv_udp_recv_start(&sockets[i], alloc_cb, recv_cb)); - ASSERT_OK(uv_udp_send(&reqs[i], - &sockets[i], - &buf, - 1, - (const struct sockaddr*) &addr, - send_cb)); + ASSERT(0 == uv_udp_init(loop, &sockets[i])); + ASSERT(0 == uv_udp_bind(&sockets[i], + (const struct sockaddr*) &addr, + UV_UDP_REUSEADDR)); + ASSERT(0 == uv_udp_recv_start(&sockets[i], alloc_cb, recv_cb)); + ASSERT(0 == uv_udp_send(&reqs[i], + &sockets[i], + &buf, + 1, + (const struct sockaddr*) &addr, + send_cb)); } while (recv_cb_called == 0) @@ -100,13 +100,13 @@ TEST_IMPL(watcher_cross_stop) { for (i = 0; i < ARRAY_SIZE(sockets); i++) uv_close((uv_handle_t*) &sockets[i], close_cb); - ASSERT_GT(recv_cb_called, 0); + ASSERT(recv_cb_called > 0); uv_run(loop, UV_RUN_DEFAULT); - ASSERT_EQ(ARRAY_SIZE(sockets), send_cb_called); - ASSERT_EQ(ARRAY_SIZE(sockets), close_cb_called); + ASSERT(ARRAY_SIZE(sockets) == send_cb_called); + ASSERT(ARRAY_SIZE(sockets) == close_cb_called); - MAKE_VALGRIND_HAPPY(loop); + MAKE_VALGRIND_HAPPY(); return 0; } diff --git a/tsansupp.txt b/tsansupp.txt deleted file mode 100644 index bde4060..0000000 --- a/tsansupp.txt +++ /dev/null @@ -1,2 +0,0 @@ -# glibc reads `count` field unsynchronized, not a libuv bug -race:pthread_barrier_destroy -- Gitee