449 lines
14 KiB
Python
449 lines
14 KiB
Python
#!/usr/bin/python3
|
|
############################################################################
|
|
# tools/ci/testrun/script/test_libuv/test_libuv.py
|
|
#
|
|
# SPDX-License-Identifier: Apache-2.0
|
|
#
|
|
# Licensed to the Apache Software Foundation (ASF) under one or more
|
|
# contributor license agreements. See the NOTICE file distributed with
|
|
# this work for additional information regarding copyright ownership. The
|
|
# ASF licenses this file to you under the Apache License, Version 2.0 (the
|
|
# "License"); you may not use this file except in compliance with the
|
|
# License. You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
# License for the specific language governing permissions and limitations
|
|
# under the License.
|
|
#
|
|
############################################################################
|
|
# encoding: utf-8
|
|
|
|
import pytest
|
|
|
|
|
|
class TestLibuv:
|
|
pytestmark = [pytest.mark.sim]
|
|
|
|
def test_test_macros(self, p):
|
|
ret = p.sendCommand(
|
|
"uv_run_tests test_macros", ["not ok 1 -", "ok 1 -"], timeout=10
|
|
)
|
|
assert ret == 1
|
|
|
|
def test_close_order(self, p):
|
|
ret = p.sendCommand(
|
|
"uv_run_tests close_order", ["not ok 1 -", "ok 1 -"], timeout=10
|
|
)
|
|
assert ret == 1
|
|
|
|
def test_run_once(self, p):
|
|
ret = p.sendCommand(
|
|
"uv_run_tests run_once", ["not ok 1 -", "ok 1 -"], timeout=10
|
|
)
|
|
assert ret == 1
|
|
|
|
def test_run_nowait(self, p):
|
|
ret = p.sendCommand(
|
|
"uv_run_tests run_nowait", ["not ok 1 -", "ok 1 -"], timeout=10
|
|
)
|
|
assert ret == 1
|
|
|
|
def test_loop_alive(self, p):
|
|
ret = p.sendCommand(
|
|
"uv_run_tests loop_alive", ["not ok 1 -", "ok 1 -"], timeout=10
|
|
)
|
|
assert ret == 1
|
|
|
|
def test_loop_close(self, p):
|
|
ret = p.sendCommand(
|
|
"uv_run_tests loop_close", ["not ok 1 -", "ok 1 -"], timeout=10
|
|
)
|
|
assert ret == 1
|
|
|
|
def test_loop_instant_close(self, p):
|
|
ret = p.sendCommand(
|
|
"uv_run_tests loop_instant_close", ["not ok 1 -", "ok 1 -"], timeout=10
|
|
)
|
|
assert ret == 1
|
|
|
|
def test_loop_stop(self, p):
|
|
ret = p.sendCommand(
|
|
"uv_run_tests loop_stop", ["not ok 1 -", "ok 1 -"], timeout=10
|
|
)
|
|
assert ret == 1
|
|
|
|
def test_loop_backend_timeout(self, p):
|
|
ret = p.sendCommand(
|
|
"uv_run_tests loop_backend_timeout", ["not ok 1 -", "ok 1 -"], timeout=10
|
|
)
|
|
assert ret == 1
|
|
|
|
def test_default_loop_close(self, p):
|
|
ret = p.sendCommand(
|
|
"uv_run_tests default_loop_close", ["not ok 1 -", "ok 1 -"], timeout=10
|
|
)
|
|
assert ret == 1
|
|
|
|
def test_barrier_1(self, p):
|
|
ret = p.sendCommand(
|
|
"uv_run_tests barrier_1", ["not ok 1 -", "ok 1 -"], timeout=10
|
|
)
|
|
assert ret == 1
|
|
|
|
def test_barrier_2(self, p):
|
|
ret = p.sendCommand(
|
|
"uv_run_tests barrier_2", ["not ok 1 -", "ok 1 -"], timeout=10
|
|
)
|
|
assert ret == 1
|
|
|
|
def test_barrier_3(self, p):
|
|
ret = p.sendCommand(
|
|
"uv_run_tests barrier_3", ["not ok 1 -", "ok 1 -"], timeout=10
|
|
)
|
|
assert ret == 1
|
|
|
|
def test_barrier_serial_thread(self, p):
|
|
ret = p.sendCommand(
|
|
"uv_run_tests barrier_serial_thread", ["not ok 1 -", "ok 1 -"], timeout=10
|
|
)
|
|
assert ret == 1
|
|
|
|
def test_barrier_serial_thread_single(self, p):
|
|
ret = p.sendCommand(
|
|
"uv_run_tests barrier_serial_thread_single",
|
|
["not ok 1 -", "ok 1 -"],
|
|
timeout=10,
|
|
)
|
|
assert ret == 1
|
|
|
|
def test_condvar_1(self, p):
|
|
ret = p.sendCommand(
|
|
"uv_run_tests condvar_1", ["not ok 1 -", "ok 1 -"], timeout=10
|
|
)
|
|
assert ret == 1
|
|
|
|
def test_condvar_2(self, p):
|
|
ret = p.sendCommand(
|
|
"uv_run_tests condvar_2", ["not ok 1 -", "ok 1 -"], timeout=10
|
|
)
|
|
assert ret == 1
|
|
|
|
def test_condvar_3(self, p):
|
|
ret = p.sendCommand(
|
|
"uv_run_tests condvar_3", ["not ok 1 -", "ok 1 -"], timeout=10
|
|
)
|
|
assert ret == 1
|
|
|
|
def test_condvar_4(self, p):
|
|
ret = p.sendCommand(
|
|
"uv_run_tests condvar_4", ["not ok 1 -", "ok 1 -"], timeout=10
|
|
)
|
|
assert ret == 1
|
|
|
|
def test_condvar_5(self, p):
|
|
ret = p.sendCommand(
|
|
"uv_run_tests condvar_5", ["not ok 1 -", "ok 1 -"], timeout=10
|
|
)
|
|
assert ret == 1
|
|
|
|
def test_semaphore_1(self, p):
|
|
ret = p.sendCommand(
|
|
"uv_run_tests semaphore_1", ["not ok 1 -", "ok 1 -"], timeout=10
|
|
)
|
|
assert ret == 1
|
|
|
|
def test_semaphore_2(self, p):
|
|
ret = p.sendCommand(
|
|
"uv_run_tests semaphore_2", ["not ok 1 -", "ok 1 -"], timeout=10
|
|
)
|
|
assert ret == 1
|
|
|
|
def test_semaphore_3(self, p):
|
|
ret = p.sendCommand(
|
|
"uv_run_tests semaphore_3", ["not ok 1 -", "ok 1 -"], timeout=10
|
|
)
|
|
assert ret == 1
|
|
|
|
def test_timer(self, p):
|
|
ret = p.sendCommand("uv_run_tests timer", ["not ok 1 -", "ok 1 -"], timeout=10)
|
|
assert ret == 1
|
|
|
|
def test_timer_init(self, p):
|
|
ret = p.sendCommand(
|
|
"uv_run_tests timer_init", ["not ok 1 -", "ok 1 -"], timeout=10
|
|
)
|
|
assert ret == 1
|
|
|
|
def test_timer_again(self, p):
|
|
ret = p.sendCommand(
|
|
"uv_run_tests timer_again", ["not ok 1 -", "ok 1 -"], timeout=10
|
|
)
|
|
assert ret == 1
|
|
|
|
def test_timer_start_twice(self, p):
|
|
ret = p.sendCommand(
|
|
"uv_run_tests timer_start_twice", ["not ok 1 -", "ok 1 -"], timeout=10
|
|
)
|
|
assert ret == 1
|
|
|
|
def test_timer_order(self, p):
|
|
ret = p.sendCommand(
|
|
"uv_run_tests timer_order", ["not ok 1 -", "ok 1 -"], timeout=10
|
|
)
|
|
assert ret == 1
|
|
|
|
def test_timer_huge_timeout(self, p):
|
|
ret = p.sendCommand(
|
|
"uv_run_tests timer_huge_timeout", ["not ok 1 -", "ok 1 -"], timeout=10
|
|
)
|
|
assert ret == 1
|
|
|
|
def test_timer_huge_repeat(self, p):
|
|
ret = p.sendCommand(
|
|
"uv_run_tests timer_huge_repeat", ["not ok 1 -", "ok 1 -"], timeout=10
|
|
)
|
|
assert ret == 1
|
|
|
|
def test_timer_run_once(self, p):
|
|
ret = p.sendCommand(
|
|
"uv_run_tests timer_run_once", ["not ok 1 -", "ok 1 -"], timeout=10
|
|
)
|
|
assert ret == 1
|
|
|
|
def test_timer_from_check(self, p):
|
|
ret = p.sendCommand(
|
|
"uv_run_tests timer_from_check", ["not ok 1 -", "ok 1 -"], timeout=10
|
|
)
|
|
assert ret == 1
|
|
|
|
def test_timer_is_closing(self, p):
|
|
ret = p.sendCommand(
|
|
"uv_run_tests timer_is_closing", ["not ok 1 -", "ok 1 -"], timeout=10
|
|
)
|
|
assert ret == 1
|
|
|
|
def test_timer_null_callback(self, p):
|
|
ret = p.sendCommand(
|
|
"uv_run_tests timer_null_callback", ["not ok 1 -", "ok 1 -"], timeout=10
|
|
)
|
|
assert ret == 1
|
|
|
|
def test_timer_early_check(self, p):
|
|
ret = p.sendCommand(
|
|
"uv_run_tests timer_early_check", ["not ok 1 -", "ok 1 -"], timeout=10
|
|
)
|
|
assert ret == 1
|
|
|
|
def test_loop_handles(self, p):
|
|
ret = p.sendCommand(
|
|
"uv_run_tests loop_handles", ["not ok 1 -", "ok 1 -"], timeout=10
|
|
)
|
|
assert ret == 1
|
|
|
|
def test_walk_handles(self, p):
|
|
ret = p.sendCommand(
|
|
"uv_run_tests walk_handles", ["not ok 1 -", "ok 1 -"], timeout=10
|
|
)
|
|
assert ret == 1
|
|
|
|
def test_active(self, p):
|
|
ret = p.sendCommand("uv_run_tests active", ["not ok 1 -", "ok 1 -"], timeout=10)
|
|
assert ret == 1
|
|
|
|
def test_embed(self, p):
|
|
if p.board in ["sim"]:
|
|
pytest.skip("unsupported at %s" % p.board)
|
|
ret = p.sendCommand("uv_run_tests embed", ["not ok 1 -", "ok 1 -"], timeout=10)
|
|
assert ret == 1
|
|
|
|
@pytest.mark.skip(reason="VELAPLATFO-6346")
|
|
def test_async(self, p):
|
|
if p.ci:
|
|
pytest.skip("unsupported at %s" % p.board)
|
|
if p.board in ["sim", "vela"]:
|
|
pytest.skip("unsupported at %s" % p.board)
|
|
ret = p.sendCommand("uv_run_tests async", ["not ok 1 -", "ok 1 -"], timeout=10)
|
|
assert ret == 1
|
|
|
|
def test_async_null_cb(self, p):
|
|
if p.ci:
|
|
pytest.skip("unsupported at %s" % p.board)
|
|
if p.board in ["sim", "vela"]:
|
|
pytest.skip("unsupported at %s" % p.board)
|
|
ret = p.sendCommand(
|
|
"uv_run_tests async_null_cb", ["not ok 1 -", "ok 1 -"], timeout=10
|
|
)
|
|
assert ret == 1
|
|
|
|
def test_homedir(self, p):
|
|
ret = p.sendCommand(
|
|
"uv_run_tests homedir", ["not ok 1 -", "ok 1 -"], timeout=10
|
|
)
|
|
assert ret == 1
|
|
|
|
def test_tmpdir(self, p):
|
|
ret = p.sendCommand("uv_run_tests tmpdir", ["not ok 1 -", "ok 1 -"], timeout=10)
|
|
assert ret == 1
|
|
|
|
def test_hrtime(self, p):
|
|
ret = p.sendCommand("uv_run_tests hrtime", ["not ok 1 -", "ok 1 -"], timeout=25)
|
|
assert ret == 1
|
|
|
|
def test_gettimeofday(self, p):
|
|
ret = p.sendCommand(
|
|
"uv_run_tests gettimeofday", ["not ok 1 -", "ok 1 -"], timeout=10
|
|
)
|
|
assert ret == 1
|
|
|
|
def test_poll_oob(self, p):
|
|
if p.board in ["sim"]:
|
|
pytest.skip("unsupported at %s" % p.board)
|
|
ret = p.sendCommand(
|
|
"uv_run_tests poll_oob", ["not ok 1 -", "ok 1 -"], timeout=10
|
|
)
|
|
assert ret == 1
|
|
|
|
def test_threadpool_queue_work_simple(self, p):
|
|
ret = p.sendCommand(
|
|
"uv_run_tests threadpool_queue_work_simple",
|
|
["not ok 1 -", "ok 1 -"],
|
|
timeout=10,
|
|
)
|
|
assert ret == 1
|
|
|
|
def test_threadpool_queue_work_einval(self, p):
|
|
ret = p.sendCommand(
|
|
"uv_run_tests threadpool_queue_work_einval",
|
|
["not ok 1 -", "ok 1 -"],
|
|
timeout=10,
|
|
)
|
|
assert ret == 1
|
|
|
|
def test_threadpool_cancel_getnameinfo(self, p):
|
|
ret = p.sendCommand(
|
|
"uv_run_tests threadpool_cancel_getnameinfo",
|
|
["not ok 1 -", "ok 1 -"],
|
|
timeout=10,
|
|
)
|
|
assert ret == 1
|
|
|
|
def test_threadpool_cancel_random(self, p):
|
|
ret = p.sendCommand(
|
|
"uv_run_tests threadpool_cancel_random",
|
|
["not ok 1 -", "ok 1 -"],
|
|
timeout=10,
|
|
)
|
|
assert ret == 1
|
|
|
|
def test_threadpool_cancel_work(self, p):
|
|
ret = p.sendCommand(
|
|
"uv_run_tests threadpool_cancel_work", ["not ok 1 -", "ok 1 -"], timeout=10
|
|
)
|
|
assert ret == 1
|
|
|
|
def test_threadpool_cancel_single(self, p):
|
|
ret = p.sendCommand(
|
|
"uv_run_tests threadpool_cancel_single",
|
|
["not ok 1 -", "ok 1 -"],
|
|
timeout=10,
|
|
)
|
|
assert ret == 1
|
|
|
|
def test_thread_local_storage(self, p):
|
|
ret = p.sendCommand(
|
|
"uv_run_tests thread_local_storage", ["not ok 1 -", "ok 1 -"], timeout=10
|
|
)
|
|
assert ret == 1
|
|
|
|
def test_thread_stack_size(self, p):
|
|
ret = p.sendCommand(
|
|
"uv_run_tests thread_stack_size", ["not ok 1 -", "ok 1 -"], timeout=10
|
|
)
|
|
assert ret == 1
|
|
|
|
def test_thread_mutex(self, p):
|
|
ret = p.sendCommand(
|
|
"uv_run_tests thread_mutex", ["not ok 1 -", "ok 1 -"], timeout=10
|
|
)
|
|
assert ret == 1
|
|
|
|
def test_thread_mutex_recursive(self, p):
|
|
ret = p.sendCommand(
|
|
"uv_run_tests thread_mutex_recursive", ["not ok 1 -", "ok 1 -"], timeout=10
|
|
)
|
|
assert ret == 1
|
|
|
|
def test_thread_rwlock(self, p):
|
|
ret = p.sendCommand(
|
|
"uv_run_tests thread_rwlock", ["not ok 1 -", "ok 1 -"], timeout=10
|
|
)
|
|
assert ret == 1
|
|
|
|
def test_thread_rwlock_trylock(self, p):
|
|
ret = p.sendCommand(
|
|
"uv_run_tests thread_rwlock_trylock", ["not ok 1 -", "ok 1 -"], timeout=10
|
|
)
|
|
assert ret == 1
|
|
|
|
def test_thread_create(self, p):
|
|
ret = p.sendCommand(
|
|
"uv_run_tests thread_create", ["not ok 1 -", "ok 1 -"], timeout=10
|
|
)
|
|
assert ret == 1
|
|
|
|
def test_thread_equal(self, p):
|
|
ret = p.sendCommand(
|
|
"uv_run_tests thread_equal", ["not ok 1 -", "ok 1 -"], timeout=10
|
|
)
|
|
assert ret == 1
|
|
|
|
def test_queue_foreach_delete(self, p):
|
|
ret = p.sendCommand(
|
|
"uv_run_tests queue_foreach_delete", ["not ok 1 -", "ok 1 -"], timeout=10
|
|
)
|
|
assert ret == 1
|
|
|
|
def test_random_async(self, p):
|
|
if p.ci:
|
|
pytest.skip("unsupported at %s" % p.board)
|
|
ret = p.sendCommand(
|
|
"uv_run_tests random_async", ["not ok 1 -", "ok 1 -"], timeout=10
|
|
)
|
|
assert ret == 1
|
|
|
|
def test_random_sync(self, p):
|
|
if p.ci:
|
|
pytest.skip("unsupported at %s" % p.board)
|
|
ret = p.sendCommand(
|
|
"uv_run_tests random_sync", ["not ok 1 -", "ok 1 -"], timeout=10
|
|
)
|
|
assert ret == 1
|
|
|
|
def test_handle_type_name(self, p):
|
|
ret = p.sendCommand(
|
|
"uv_run_tests handle_type_name", ["not ok 1 -", "ok 1 -"], timeout=10
|
|
)
|
|
assert ret == 1
|
|
|
|
def test_req_type_name(self, p):
|
|
ret = p.sendCommand(
|
|
"uv_run_tests req_type_name", ["not ok 1 -", "ok 1 -"], timeout=10
|
|
)
|
|
assert ret == 1
|
|
|
|
def test_utf8_decode1(self, p):
|
|
ret = p.sendCommand(
|
|
"uv_run_tests utf8_decode1", ["not ok 1 -", "ok 1 -"], timeout=10
|
|
)
|
|
assert ret == 1
|
|
|
|
def test_utf8_decode1_overrun(self, p):
|
|
ret = p.sendCommand(
|
|
"uv_run_tests utf8_decode1_overrun", ["not ok 1 -", "ok 1 -"], timeout=10
|
|
)
|
|
assert ret == 1
|