Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

test_threading: test_set_and_clear() failed on Windows x64 #109974

Closed
vstinner opened this issue Sep 27, 2023 · 0 comments
Closed

test_threading: test_set_and_clear() failed on Windows x64 #109974

vstinner opened this issue Sep 27, 2023 · 0 comments
Labels
tests Tests in the Lib/test dir

Comments

@vstinner
Copy link
Member

vstinner commented Sep 27, 2023 •
edited by bedevere-app bot
Loading

Windows x64:

FAIL: test_set_and_clear (test.test_threading.EventTests.test_set_and_clear)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "D:\a\cpython\cpython\Lib\test\lock_tests.py", line 481, in test_set_and_clear
    self.assertEqual(results, [True] * N)
AssertionError: Lists differ: [False, True, True, True, True] != [True, True, True, True, True]

First differing element 0:
False
True

- [False, True, True, True, True]
?  -------

+ [True, True, True, True, True]
?                    ++++++

The test passed when re-run:

0:19:31 load avg: 9.73 Run 2 tests in parallel using 2 worker processes (timeout: 10 min, worker timeout: 15 min)
0:19:33 load avg: 9.53 [1/2] test_threading passed
Re-running test_threading in verbose mode (matching: test_set_and_clear)
test_set_and_clear (test.test_threading.EventTests.test_set_and_clear) ... ok

----------------------------------------------------------------------
Ran 1 test in 0.766s

OK

build: https://github.com/python/cpython/actions/runs/6323487736/job/17171157457?pr=109922

Linked PRs
@vstinner vstinner added the tests Tests in the Lib/test dir label Sep 27, 2023
@vstinner vstinner mentioned this issue Sep 27, 2023
Merged
vstinner added a commit to vstinner/cpython that referenced this issue Sep 28, 2023
@vstinner
pythongh-109974: Fix lock_tests: adjust timeouts
c460bfe 
* test_set_and_clear(): increase event wait()
  timeout. Remove sleep after Bunch.wait_for_started().
* BarrierTests.test_repr(): remove sleep after wait_for_started().
  Use way longer timeout for Barrier.wait() timeout.
* test_thread_leak() no longer needs to count
  len(threading.enumerate()): Bunch use
  threading_helper.wait_threads_exit() internally which does it in
  wait_for_finished().
vstinner added a commit to vstinner/cpython that referenced this issue Sep 28, 2023
@vstinner
pythongh-109974: Fix threading lock_tests: adjust timeouts
5a4f13e 
* test_set_and_clear(): increase event wait()
  timeout. Remove sleep after Bunch.wait_for_started().
* BarrierTests.test_repr(): remove sleep after wait_for_started().
  Use way longer timeout for Barrier.wait() timeout.
* test_thread_leak() no longer needs to count
  len(threading.enumerate()): Bunch use
  threading_helper.wait_threads_exit() internally which does it in
  wait_for_finished().
vstinner added a commit to vstinner/cpython that referenced this issue Sep 28, 2023
@vstinner
pythongh-109974: Fix threading lock_tests: adjust timeouts
3e81f9c 
* test_set_and_clear(): increase event wait()
  timeout. Remove sleep after Bunch.wait_for_started().
* BarrierTests.test_repr(): remove sleep after wait_for_started().
  Use way longer timeout for Barrier.wait() timeout.
* test_thread_leak() no longer needs to count
  len(threading.enumerate()): Bunch uses
  threading_helper.wait_threads_exit() internally which does it in
  wait_for_finished().
vstinner added a commit to vstinner/cpython that referenced this issue Sep 28, 2023
@vstinner
pythongh-109974: Fix threading lock_tests: adjust timeouts
f8fb3fa 
* test_set_and_clear(): increase event wait()
  timeout. Remove sleep after Bunch.wait_for_started().
* BarrierTests.test_repr(): remove sleep after wait_for_started().
  Use way longer timeout for Barrier.wait() timeout.
* test_thread_leak() no longer needs to count
  len(threading.enumerate()): Bunch uses
  threading_helper.wait_threads_exit() internally which does it in
  wait_for_finished().
vstinner added a commit to vstinner/cpython that referenced this issue Sep 28, 2023
@vstinner
pythongh-109974: Enhance threading lock_tests
d8f4003 
* Replace sleeping loops with support.sleeping_retry() which raises
  an exception after a timeout.
* test_set_and_clear(): increase event wait()
  timeout. Remove sleep after Bunch.wait_for_started().
* BarrierTests.test_repr(): remove sleep after wait_for_started().
  Wait until the 2 threads are waiting for the barrier.
  Use long timeout for Barrier.wait() timeout.
* test_thread_leak() no longer needs to count
  len(threading.enumerate()): Bunch uses
  threading_helper.wait_threads_exit() internally which does it in
  wait_for_finished().
* Add BaseLockTests.wait_phase() which implements a timeout.
  test_reacquire() and test_recursion_count() use wait_phase().
vstinner added a commit to vstinner/cpython that referenced this issue Sep 28, 2023
@vstinner
pythongh-109974: Enhance threading lock_tests
38b34b8 
* Replace sleeping loops with support.sleeping_retry() which raises
  an exception on timeout.
* Add wait_threads_blocked(nthread) which computes a sleep depending
  on the number of threads.
* test_set_and_clear(): use a way longer Event.wait() timeout.
* BarrierTests.test_repr(): wait until the 2 threads are waiting for
  the barrier. Use a way longer timeout for Barrier.wait() timeout.
* test_thread_leak() no longer needs to count
  len(threading.enumerate()): Bunch uses
  threading_helper.wait_threads_exit() internally which does it in
  wait_for_finished().
* Add BaseLockTests.wait_phase() which implements a timeout.
  test_reacquire() and test_recursion_count() use wait_phase().
vstinner added a commit to vstinner/cpython that referenced this issue Sep 28, 2023
@vstinner
pythongh-109974: Fix threading lock_tests race conditions
81b5b76 
Fix race conditions in test_threading lock tests. Wait until a
condition is met rather than using time.sleep() with a hardcoded
number of seconds.

* Replace sleeping loops with support.sleeping_retry() which raises
  an exception on timeout.
* Add wait_threads_blocked(nthread) which computes a sleep depending
  on the number of threads.
* test_set_and_clear(): use a way longer Event.wait() timeout.
* BarrierTests.test_repr(): wait until the 2 threads are waiting for
  the barrier. Use a way longer timeout for Barrier.wait() timeout.
* test_thread_leak() no longer needs to count
  len(threading.enumerate()): Bunch uses
  threading_helper.wait_threads_exit() internally which does it in
  wait_for_finished().
* Add BaseLockTests.wait_phase() which implements a timeout.
  test_reacquire() and test_recursion_count() use wait_phase().
vstinner added a commit to vstinner/cpython that referenced this issue Sep 28, 2023
@vstinner
pythongh-109974: Fix threading lock_tests race conditions
b0e83e0 
Fix race conditions in test_threading lock tests. Wait until a
condition is met rather than using time.sleep() with a hardcoded
number of seconds.

* Replace sleeping loops with support.sleeping_retry() which raises
  an exception on timeout.
* Add wait_threads_blocked(nthread) which computes a sleep depending
  on the number of threads. Remove _wait() function.
* test_set_and_clear(): use a way longer Event.wait() timeout.
* BarrierTests.test_repr(): wait until the 2 threads are waiting for
  the barrier. Use a way longer timeout for Barrier.wait() timeout.
* test_thread_leak() no longer needs to count
  len(threading.enumerate()): Bunch uses
  threading_helper.wait_threads_exit() internally which does it in
  wait_for_finished().
* Add BaseLockTests.wait_phase() which implements a timeout.
  test_reacquire() and test_recursion_count() use wait_phase().
vstinner added a commit to vstinner/cpython that referenced this issue Sep 28, 2023
@vstinner
pythongh-109974: Fix threading lock_tests race conditions
c1c9f46 
Fix race conditions in test_threading lock tests. Wait until a
condition is met rather than using time.sleep() with a hardcoded
number of seconds.

* Replace sleeping loops with support.sleeping_retry() which raises
  an exception on timeout.
* Add wait_threads_blocked(nthread) which computes a sleep depending
  on the number of threads. Remove _wait() function.
* test_set_and_clear(): use a way longer Event.wait() timeout.
* BarrierTests.test_repr(): wait until the 2 threads are waiting for
  the barrier. Use a way longer timeout for Barrier.wait() timeout.
* test_thread_leak() no longer needs to count
  len(threading.enumerate()): Bunch uses
  threading_helper.wait_threads_exit() internally which does it in
  wait_for_finished().
* Add BaseLockTests.wait_phase() which implements a timeout.
  test_reacquire() and test_recursion_count() use wait_phase().
vstinner added a commit to vstinner/cpython that referenced this issue Sep 28, 2023
@vstinner
pythongh-109974: Fix threading lock_tests race conditions
37a2b2f 
Fix race conditions in test_threading lock tests. Wait until a
condition is met rather than using time.sleep() with a hardcoded
number of seconds.

* Replace sleeping loops with support.sleeping_retry() which raises
  an exception on timeout.
* Add wait_threads_blocked(nthread) which computes a sleep depending
  on the number of threads. Remove _wait() function.
* test_set_and_clear(): use a way longer Event.wait() timeout.
* BarrierTests.test_repr(): wait until the 2 threads are waiting for
  the barrier. Use a way longer timeout for Barrier.wait() timeout.
* test_thread_leak() no longer needs to count
  len(threading.enumerate()): Bunch uses
  threading_helper.wait_threads_exit() internally which does it in
  wait_for_finished().
* Add BaseLockTests.wait_phase() which implements a timeout.
  test_reacquire() and test_recursion_count() use wait_phase().
vstinner added a commit to vstinner/cpython that referenced this issue Sep 28, 2023
@vstinner
pythongh-109974: Fix threading lock_tests race conditions
74cd58d 
Fix race conditions in test_threading lock tests. Wait until a
condition is met rather than using time.sleep() with a hardcoded
number of seconds.

* Replace sleeping loops with support.sleeping_retry() which raises
  an exception on timeout.
* Add wait_threads_blocked(nthread) which computes a sleep depending
  on the number of threads. Remove _wait() function.
* test_set_and_clear(): use a way longer Event.wait() timeout.
* BarrierTests.test_repr(): wait until the 2 threads are waiting for
  the barrier. Use a way longer timeout for Barrier.wait() timeout.
* test_thread_leak() no longer needs to count
  len(threading.enumerate()): Bunch uses
  threading_helper.wait_threads_exit() internally which does it in
  wait_for_finished().
* Add BaseLockTests.wait_phase() which implements a timeout.
  test_reacquire() and test_recursion_count() use wait_phase().
@bedevere-app bedevere-app bot mentioned this issue Sep 28, 2023
Merged
vstinner added a commit that referenced this issue Sep 29, 2023
@vstinner
gh-109974: Fix threading lock_tests race conditions (#110057)
4e356ad 
Fix race conditions in test_threading lock tests. Wait until a
condition is met rather than using time.sleep() with a hardcoded
number of seconds.

* Replace sleeping loops with support.sleeping_retry() which raises
  an exception on timeout.
* Add wait_threads_blocked(nthread) which computes a sleep depending
  on the number of threads. Remove _wait() function.
* test_set_and_clear(): use a way longer Event.wait() timeout.
* BarrierTests.test_repr(): wait until the 2 threads are waiting for
  the barrier. Use a way longer timeout for Barrier.wait() timeout.
* test_thread_leak() no longer needs to count
  len(threading.enumerate()): Bunch uses
  threading_helper.wait_threads_exit() internally which does it in
  wait_for_finished().
* Add BaseLockTests.wait_phase() which implements a timeout.
  test_reacquire() and test_recursion_count() use wait_phase().
miss-islington pushed a commit to miss-islington/cpython that referenced this issue Sep 29, 2023
@vstinner @miss-islington
pythongh-109974: Fix threading lock_tests race conditions (pythonGH-1…
46a0d2f 
…10057)

Fix race conditions in test_threading lock tests. Wait until a
condition is met rather than using time.sleep() with a hardcoded
number of seconds.

* Replace sleeping loops with support.sleeping_retry() which raises
  an exception on timeout.
* Add wait_threads_blocked(nthread) which computes a sleep depending
  on the number of threads. Remove _wait() function.
* test_set_and_clear(): use a way longer Event.wait() timeout.
* BarrierTests.test_repr(): wait until the 2 threads are waiting for
  the barrier. Use a way longer timeout for Barrier.wait() timeout.
* test_thread_leak() no longer needs to count
  len(threading.enumerate()): Bunch uses
  threading_helper.wait_threads_exit() internally which does it in
  wait_for_finished().
* Add BaseLockTests.wait_phase() which implements a timeout.
  test_reacquire() and test_recursion_count() use wait_phase().
(cherry picked from commit 4e356ad)

Co-authored-by: Victor Stinner <[email protected]>
@bedevere-app bedevere-app bot mentioned this issue Sep 29, 2023
Closed
vstinner added a commit to vstinner/cpython that referenced this issue Sep 29, 2023
@vstinner
pythongh-109974: Fix more threading lock_tests race conditions
f7da77d 
* Add context manager on Bunch class.
* Bunch now catchs exceptions on executed functions and re-raise them
  at __exit__() as an ExceptionGroup.
* Rewrite BarrierProxy.test_default_timeout(). Use a single thread.
  Only check that barrier.wait() blocks for at least default timeout
  seconds.
vstinner added a commit to vstinner/cpython that referenced this issue Sep 29, 2023
@vstinner
pythongh-109974: Fix more threading lock_tests race conditions
68d5deb 
* Add context manager on Bunch class.
* Bunch now catchs exceptions on executed functions and re-raise them
  at __exit__() as an ExceptionGroup.
* Rewrite BarrierProxy.test_default_timeout(). Use a single thread.
  Only check that barrier.wait() blocks for at least default timeout
  seconds.
* test_with(): inline _with() function.
@bedevere-app bedevere-app bot mentioned this issue Sep 29, 2023
Merged
vstinner added a commit to vstinner/cpython that referenced this issue Sep 29, 2023
@vstinner
pythongh-109974: Fix more threading lock_tests race conditions
7173696 
* Add context manager on Bunch class.
* Bunch now catchs exceptions on executed functions and re-raise them
  at __exit__() as an ExceptionGroup.
* Rewrite BarrierProxy.test_default_timeout(). Use a single thread.
  Only check that barrier.wait() blocks for at least default timeout
  seconds.
* test_with(): inline _with() function.
vstinner added a commit that referenced this issue Sep 29, 2023
@vstinner
gh-109974: Fix more threading lock_tests race conditions (#110089)
743e357 
* Add context manager on Bunch class.
* Bunch now catchs exceptions on executed functions and re-raise them
  at __exit__() as an ExceptionGroup.
* Rewrite BarrierProxy.test_default_timeout(). Use a single thread.
  Only check that barrier.wait() blocks for at least default timeout
  seconds.
* test_with(): inline _with() function.
miss-islington pushed a commit to miss-islington/cpython that referenced this issue Oct 4, 2023
@vstinner @miss-islington
pythongh-109974: Fix threading lock_tests race conditions (pythonGH-1…
7303587 
…10057)

Fix race conditions in test_threading lock tests. Wait until a
condition is met rather than using time.sleep() with a hardcoded
number of seconds.

* Replace sleeping loops with support.sleeping_retry() which raises
  an exception on timeout.
* Add wait_threads_blocked(nthread) which computes a sleep depending
  on the number of threads. Remove _wait() function.
* test_set_and_clear(): use a way longer Event.wait() timeout.
* BarrierTests.test_repr(): wait until the 2 threads are waiting for
  the barrier. Use a way longer timeout for Barrier.wait() timeout.
* test_thread_leak() no longer needs to count
  len(threading.enumerate()): Bunch uses
  threading_helper.wait_threads_exit() internally which does it in
  wait_for_finished().
* Add BaseLockTests.wait_phase() which implements a timeout.
  test_reacquire() and test_recursion_count() use wait_phase().
(cherry picked from commit 4e356ad)

Co-authored-by: Victor Stinner <[email protected]>
@bedevere-app bedevere-app bot mentioned this issue Oct 4, 2023
Closed
vstinner added a commit to vstinner/cpython that referenced this issue Oct 4, 2023
@vstinner
pythongh-109974: Fix threading lock_tests race conditions (python#110057
f72c926 
)

Fix race conditions in test_threading lock tests. Wait until a
condition is met rather than using time.sleep() with a hardcoded
number of seconds.

* Replace sleeping loops with support.sleeping_retry() which raises
  an exception on timeout.
* Add wait_threads_blocked(nthread) which computes a sleep depending
  on the number of threads. Remove _wait() function.
* test_set_and_clear(): use a way longer Event.wait() timeout.
* BarrierTests.test_repr(): wait until the 2 threads are waiting for
  the barrier. Use a way longer timeout for Barrier.wait() timeout.
* test_thread_leak() no longer needs to count
  len(threading.enumerate()): Bunch uses
  threading_helper.wait_threads_exit() internally which does it in
  wait_for_finished().
* Add BaseLockTests.wait_phase() which implements a timeout.
  test_reacquire() and test_recursion_count() use wait_phase().

(cherry picked from commit 4e356ad)
vstinner added a commit to vstinner/cpython that referenced this issue Oct 4, 2023
@vstinner
pythongh-109974: Fix more threading lock_tests race conditions (pytho…
8a4668a 
…n#110089)

* Add context manager on Bunch class.
* Bunch now catchs exceptions on executed functions and re-raise them
  at __exit__() as an ExceptionGroup.
* Rewrite BarrierProxy.test_default_timeout(). Use a single thread.
  Only check that barrier.wait() blocks for at least default timeout
  seconds.
* test_with(): inline _with() function.

(cherry picked from commit 743e357)
@bedevere-app bedevere-app bot mentioned this issue Oct 4, 2023
Merged
vstinner added a commit that referenced this issue Oct 4, 2023
@vstinner
[3.12] gh-109974: Fix threading lock_tests race conditions (#110057) (#…
1d032ea 
…110346)

* gh-109974: Fix threading lock_tests race conditions (#110057)

Fix race conditions in test_threading lock tests. Wait until a
condition is met rather than using time.sleep() with a hardcoded
number of seconds.

* Replace sleeping loops with support.sleeping_retry() which raises
  an exception on timeout.
* Add wait_threads_blocked(nthread) which computes a sleep depending
  on the number of threads. Remove _wait() function.
* test_set_and_clear(): use a way longer Event.wait() timeout.
* BarrierTests.test_repr(): wait until the 2 threads are waiting for
  the barrier. Use a way longer timeout for Barrier.wait() timeout.
* test_thread_leak() no longer needs to count
  len(threading.enumerate()): Bunch uses
  threading_helper.wait_threads_exit() internally which does it in
  wait_for_finished().
* Add BaseLockTests.wait_phase() which implements a timeout.
  test_reacquire() and test_recursion_count() use wait_phase().

(cherry picked from commit 4e356ad)

* gh-109974: Fix more threading lock_tests race conditions (#110089)

* Add context manager on Bunch class.
* Bunch now catchs exceptions on executed functions and re-raise them
  at __exit__() as an ExceptionGroup.
* Rewrite BarrierProxy.test_default_timeout(). Use a single thread.
  Only check that barrier.wait() blocks for at least default timeout
  seconds.
* test_with(): inline _with() function.

(cherry picked from commit 743e357)
@vstinner vstinner mentioned this issue Oct 4, 2023
Merged
vstinner added a commit that referenced this issue Oct 4, 2023
@vstinner
[3.11] gh-109974: Fix threading lock_tests race conditions (#110057) (#…
8f22504 
…110355)

[3.12] gh-109974: Fix threading lock_tests race conditions (#110057) (#110346)

* gh-109974: Fix threading lock_tests race conditions (#110057)

Fix race conditions in test_threading lock tests. Wait until a
condition is met rather than using time.sleep() with a hardcoded
number of seconds.

* Replace sleeping loops with support.sleeping_retry() which raises
  an exception on timeout.
* Add wait_threads_blocked(nthread) which computes a sleep depending
  on the number of threads. Remove _wait() function.
* test_set_and_clear(): use a way longer Event.wait() timeout.
* BarrierTests.test_repr(): wait until the 2 threads are waiting for
  the barrier. Use a way longer timeout for Barrier.wait() timeout.
* test_thread_leak() no longer needs to count
  len(threading.enumerate()): Bunch uses
  threading_helper.wait_threads_exit() internally which does it in
  wait_for_finished().
* Add BaseLockTests.wait_phase() which implements a timeout.
  test_reacquire() and test_recursion_count() use wait_phase().

(cherry picked from commit 4e356ad)

* gh-109974: Fix more threading lock_tests race conditions (#110089)

* Add context manager on Bunch class.
* Bunch now catchs exceptions on executed functions and re-raise them
  at __exit__() as an ExceptionGroup.
* Rewrite BarrierProxy.test_default_timeout(). Use a single thread.
  Only check that barrier.wait() blocks for at least default timeout
  seconds.
* test_with(): inline _with() function.

(cherry picked from commit 743e357)
(cherry picked from commit 1d032ea)
Glyphack pushed a commit to Glyphack/cpython that referenced this issue Sep 2, 2024
@vstinner @Glyphack
pythongh-109974: Fix threading lock_tests race conditions (python#110057
9768e65 
)

Fix race conditions in test_threading lock tests. Wait until a
condition is met rather than using time.sleep() with a hardcoded
number of seconds.

* Replace sleeping loops with support.sleeping_retry() which raises
  an exception on timeout.
* Add wait_threads_blocked(nthread) which computes a sleep depending
  on the number of threads. Remove _wait() function.
* test_set_and_clear(): use a way longer Event.wait() timeout.
* BarrierTests.test_repr(): wait until the 2 threads are waiting for
  the barrier. Use a way longer timeout for Barrier.wait() timeout.
* test_thread_leak() no longer needs to count
  len(threading.enumerate()): Bunch uses
  threading_helper.wait_threads_exit() internally which does it in
  wait_for_finished().
* Add BaseLockTests.wait_phase() which implements a timeout.
  test_reacquire() and test_recursion_count() use wait_phase().
Glyphack pushed a commit to Glyphack/cpython that referenced this issue Sep 2, 2024
@vstinner @Glyphack
pythongh-109974: Fix more threading lock_tests race conditions (pytho…
bbd1437 
…n#110089)

* Add context manager on Bunch class.
* Bunch now catchs exceptions on executed functions and re-raise them
  at __exit__() as an ExceptionGroup.
* Rewrite BarrierProxy.test_default_timeout(). Use a single thread.
  Only check that barrier.wait() blocks for at least default timeout
  seconds.
* test_with(): inline _with() function.
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Assignees
No one assigned
Labels
tests Tests in the Lib/test dir
Projects
None yet
Milestone
No milestone
Development

No branches or pull requests
1 participant
@vstinner