Skip to content

Commit 44ee235

Browse files
hroncokhroncok
committed
Update unittest asserts to support Python 3.12+
Related to python/cpython#89325
1 parent dd2f0ea commit 44ee235

2 files changed

Lines changed: 65 additions & 65 deletions

File tree

‎tests/dagpool_test.py‎

Lines changed: 62 additions & 62 deletions
Original file line numberDiff line numberDiff line change
@@ -191,14 +191,14 @@ def test_init():
191191
with check_no_suspend():
192192
results = pool.waitall()
193193
# with no spawn() or post(), waitall() returns preload data
194-
assert_equals(results, dict(a=1, b=2, c=3))
194+
assert_equal(results, dict(a=1, b=2, c=3))
195195

196196
# preload sequence of pairs
197197
pool = DAGPool([("d", 4), ("e", 5), ("f", 6)])
198198
# this must not hang
199199
with check_no_suspend():
200200
results = pool.waitall()
201-
assert_equals(results, dict(d=4, e=5, f=6))
201+
assert_equal(results, dict(d=4, e=5, f=6))
202202

203203

204204
def test_wait_each_empty():
@@ -216,10 +216,10 @@ def test_wait_each_preload():
216216
with check_no_suspend():
217217
# wait_each() may deliver in arbitrary order; collect into a dict
218218
# for comparison
219-
assert_equals(dict(pool.wait_each("abc")), dict(a=1, b=2, c=3))
219+
assert_equal(dict(pool.wait_each("abc")), dict(a=1, b=2, c=3))
220220

221221
# while we're at it, test wait() for preloaded keys
222-
assert_equals(pool.wait("bc"), dict(b=2, c=3))
222+
assert_equal(pool.wait("bc"), dict(b=2, c=3))
223223

224224

225225
def post_each(pool, capture):
@@ -257,7 +257,7 @@ def test_wait_posted():
257257
eventlet.spawn(post_each, pool, capture)
258258
gotten = pool.wait("bcdefg")
259259
capture.add("got all")
260-
assert_equals(gotten,
260+
assert_equal(gotten,
261261
dict(b=2, c=3,
262262
d="dval", e="eval",
263263
f="fval", g="gval"))
@@ -285,15 +285,15 @@ def test_spawn_collision_spawn():
285285
pool = DAGPool()
286286
pool.spawn("a", (), lambda key, results: "aval")
287287
# hasn't yet even started
288-
assert_equals(pool.get("a"), None)
288+
assert_equal(pool.get("a"), None)
289289
with assert_raises(Collision):
290290
# Attempting to spawn again with same key should collide even if the
291291
# first spawned greenthread hasn't yet had a chance to run.
292292
pool.spawn("a", (), lambda key, results: "bad")
293293
# now let the spawned eventlet run
294294
eventlet.sleep(0)
295295
# should have finished
296-
assert_equals(pool.get("a"), "aval")
296+
assert_equal(pool.get("a"), "aval")
297297
with assert_raises(Collision):
298298
# Attempting to spawn with same key collides even when the greenthread
299299
# has completed.
@@ -324,60 +324,60 @@ def test_spawn_multiple():
324324
capture.step()
325325
# but none of them has yet produced a result
326326
for k in "defgh":
327-
assert_equals(pool.get(k), None)
328-
assert_equals(set(pool.keys()), set("abc"))
329-
assert_equals(dict(pool.items()), dict(a=1, b=2, c=3))
330-
assert_equals(pool.running(), 5)
331-
assert_equals(set(pool.running_keys()), set("defgh"))
332-
assert_equals(pool.waiting(), 1)
333-
assert_equals(pool.waiting_for(), dict(h=set("defg")))
334-
assert_equals(pool.waiting_for("d"), set())
335-
assert_equals(pool.waiting_for("c"), set())
327+
assert_equal(pool.get(k), None)
328+
assert_equal(set(pool.keys()), set("abc"))
329+
assert_equal(dict(pool.items()), dict(a=1, b=2, c=3))
330+
assert_equal(pool.running(), 5)
331+
assert_equal(set(pool.running_keys()), set("defgh"))
332+
assert_equal(pool.waiting(), 1)
333+
assert_equal(pool.waiting_for(), dict(h=set("defg")))
334+
assert_equal(pool.waiting_for("d"), set())
335+
assert_equal(pool.waiting_for("c"), set())
336336
with assert_raises(KeyError):
337337
pool.waiting_for("j")
338-
assert_equals(pool.waiting_for("h"), set("defg"))
338+
assert_equal(pool.waiting_for("h"), set("defg"))
339339

340340
# let one of the upstream greenthreads complete
341341
events["f"].send("fval")
342342
spin()
343343
capture.step()
344-
assert_equals(pool.get("f"), "fval")
345-
assert_equals(set(pool.keys()), set("abcf"))
346-
assert_equals(dict(pool.items()), dict(a=1, b=2, c=3, f="fval"))
347-
assert_equals(pool.running(), 4)
348-
assert_equals(set(pool.running_keys()), set("degh"))
349-
assert_equals(pool.waiting(), 1)
350-
assert_equals(pool.waiting_for("h"), set("deg"))
344+
assert_equal(pool.get("f"), "fval")
345+
assert_equal(set(pool.keys()), set("abcf"))
346+
assert_equal(dict(pool.items()), dict(a=1, b=2, c=3, f="fval"))
347+
assert_equal(pool.running(), 4)
348+
assert_equal(set(pool.running_keys()), set("degh"))
349+
assert_equal(pool.waiting(), 1)
350+
assert_equal(pool.waiting_for("h"), set("deg"))
351351

352352
# now two others
353353
events["e"].send("eval")
354354
events["g"].send("gval")
355355
spin()
356356
capture.step()
357-
assert_equals(pool.get("e"), "eval")
358-
assert_equals(pool.get("g"), "gval")
359-
assert_equals(set(pool.keys()), set("abcefg"))
360-
assert_equals(dict(pool.items()),
357+
assert_equal(pool.get("e"), "eval")
358+
assert_equal(pool.get("g"), "gval")
359+
assert_equal(set(pool.keys()), set("abcefg"))
360+
assert_equal(dict(pool.items()),
361361
dict(a=1, b=2, c=3, e="eval", f="fval", g="gval"))
362-
assert_equals(pool.running(), 2)
363-
assert_equals(set(pool.running_keys()), set("dh"))
364-
assert_equals(pool.waiting(), 1)
365-
assert_equals(pool.waiting_for("h"), set("d"))
362+
assert_equal(pool.running(), 2)
363+
assert_equal(set(pool.running_keys()), set("dh"))
364+
assert_equal(pool.waiting(), 1)
365+
assert_equal(pool.waiting_for("h"), set("d"))
366366

367367
# last one
368368
events["d"].send("dval")
369369
# make sure both pool greenthreads get a chance to run
370370
spin()
371371
capture.step()
372-
assert_equals(pool.get("d"), "dval")
373-
assert_equals(set(pool.keys()), set("abcdefgh"))
374-
assert_equals(dict(pool.items()),
372+
assert_equal(pool.get("d"), "dval")
373+
assert_equal(set(pool.keys()), set("abcdefgh"))
374+
assert_equal(dict(pool.items()),
375375
dict(a=1, b=2, c=3,
376376
d="dval", e="eval", f="fval", g="gval", h="hval"))
377-
assert_equals(pool.running(), 0)
377+
assert_equal(pool.running(), 0)
378378
assert_false(pool.running_keys())
379-
assert_equals(pool.waiting(), 0)
380-
assert_equals(pool.waiting_for("h"), set())
379+
assert_equal(pool.waiting(), 0)
380+
assert_equal(pool.waiting_for("h"), set())
381381

382382
capture.validate([
383383
["h got b", "h got c"],
@@ -432,13 +432,13 @@ def test_spawn_many():
432432
spin()
433433
# verify that e completed (also that post(key) within greenthread
434434
# overrides implicit post of return value, which would be None)
435-
assert_equals(pool.get("e"), "e")
435+
assert_equal(pool.get("e"), "e")
436436

437437
# With the dependency graph shown above, it is not guaranteed whether b or
438438
# c will complete first. Handle either case.
439439
sequence = capture.sequence[:]
440440
sequence[1:3] = [set([sequence[1].pop(), sequence[2].pop()])]
441-
assert_equals(sequence,
441+
assert_equal(sequence,
442442
[set(["a done"]),
443443
set(["b done", "c done"]),
444444
set(["d done"]),
@@ -466,7 +466,7 @@ def test_wait_each_all():
466466
for pos in range(len(keys)):
467467
# next value from wait_each()
468468
k, v = next(each)
469-
assert_equals(k, keys[pos])
469+
assert_equal(k, keys[pos])
470470
# advance every pool greenlet as far as it can go
471471
spin()
472472
# everything from keys[:pos+1] should have a value by now
@@ -494,7 +494,7 @@ def test_kill():
494494
pool.kill("a")
495495
# didn't run
496496
spin()
497-
assert_equals(pool.get("a"), None)
497+
assert_equal(pool.get("a"), None)
498498
# killing it forgets about it
499499
with assert_raises(KeyError):
500500
pool.kill("a")
@@ -505,7 +505,7 @@ def test_kill():
505505
with assert_raises(KeyError):
506506
pool.kill("a")
507507
# verify it ran to completion
508-
assert_equals(pool.get("a"), 2)
508+
assert_equal(pool.get("a"), 2)
509509

510510

511511
def test_post_collision_preload():
@@ -533,7 +533,7 @@ def test_post_collision_spawn():
533533
pool.kill("a")
534534
# now we can post
535535
pool.post("a", 3)
536-
assert_equals(pool.get("a"), 3)
536+
assert_equal(pool.get("a"), 3)
537537

538538
pool = DAGPool()
539539
pool.spawn("a", (), lambda key, result: 4)
@@ -553,10 +553,10 @@ def test_post_replace():
553553
pool = DAGPool()
554554
pool.post("a", 1)
555555
pool.post("a", 2, replace=True)
556-
assert_equals(pool.get("a"), 2)
557-
assert_equals(dict(pool.wait_each("a")), dict(a=2))
558-
assert_equals(pool.wait("a"), dict(a=2))
559-
assert_equals(pool["a"], 2)
556+
assert_equal(pool.get("a"), 2)
557+
assert_equal(dict(pool.wait_each("a")), dict(a=2))
558+
assert_equal(pool.wait("a"), dict(a=2))
559+
assert_equal(pool["a"], 2)
560560

561561

562562
def waitfor(capture, pool, key):
@@ -598,10 +598,10 @@ def test_waitall_exc():
598598
try:
599599
pool.waitall()
600600
except PropagateError as err:
601-
assert_equals(err.key, "a")
601+
assert_equal(err.key, "a")
602602
assert isinstance(err.exc, BogusError), \
603603
"exc attribute is {0}, not BogusError".format(err.exc)
604-
assert_equals(str(err.exc), "bogus")
604+
assert_equal(str(err.exc), "bogus")
605605
msg = str(err)
606606
assert_in("PropagateError(a)", msg)
607607
assert_in("BogusError", msg)
@@ -616,14 +616,14 @@ def test_propagate_exc():
616616
try:
617617
pool["c"]
618618
except PropagateError as errc:
619-
assert_equals(errc.key, "c")
619+
assert_equal(errc.key, "c")
620620
errb = errc.exc
621-
assert_equals(errb.key, "b")
621+
assert_equal(errb.key, "b")
622622
erra = errb.exc
623-
assert_equals(erra.key, "a")
623+
assert_equal(erra.key, "a")
624624
assert isinstance(erra.exc, BogusError), \
625625
"exc attribute is {0}, not BogusError".format(erra.exc)
626-
assert_equals(str(erra.exc), "bogus")
626+
assert_equal(str(erra.exc), "bogus")
627627
msg = str(errc)
628628
assert_in("PropagateError(a)", msg)
629629
assert_in("PropagateError(b)", msg)
@@ -681,13 +681,13 @@ def test_post_get_exc():
681681
pass
682682

683683
# wait_each_success() filters
684-
assert_equals(dict(pool.wait_each_success()), dict(a=bogua))
685-
assert_equals(dict(pool.wait_each_success("ab")), dict(a=bogua))
686-
assert_equals(dict(pool.wait_each_success("a")), dict(a=bogua))
687-
assert_equals(dict(pool.wait_each_success("b")), {})
684+
assert_equal(dict(pool.wait_each_success()), dict(a=bogua))
685+
assert_equal(dict(pool.wait_each_success("ab")), dict(a=bogua))
686+
assert_equal(dict(pool.wait_each_success("a")), dict(a=bogua))
687+
assert_equal(dict(pool.wait_each_success("b")), {})
688688

689689
# wait_each_exception() filters the other way
690-
assert_equals(dict(pool.wait_each_exception()), dict(b=bogub))
691-
assert_equals(dict(pool.wait_each_exception("ab")), dict(b=bogub))
692-
assert_equals(dict(pool.wait_each_exception("a")), {})
693-
assert_equals(dict(pool.wait_each_exception("b")), dict(b=bogub))
690+
assert_equal(dict(pool.wait_each_exception()), dict(b=bogub))
691+
assert_equal(dict(pool.wait_each_exception("ab")), dict(b=bogub))
692+
assert_equal(dict(pool.wait_each_exception("a")), {})
693+
assert_equal(dict(pool.wait_each_exception("b")), dict(b=bogub))

‎tests/tpool_test.py‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -287,11 +287,11 @@ class TpoolLongTests(tests.LimitedTestCase):
287287
TEST_TIMEOUT = 60
288288

289289
def test_a_buncha_stuff(self):
290-
assert_ = self.assert_
290+
assertTrue = self.assertTrue
291291

292292
class Dummy(object):
293293
def foo(self, when, token=None):
294-
assert_(token is not None)
294+
assertTrue(token is not None)
295295
time.sleep(random.random() / 200.0)
296296
return token
297297

@@ -330,7 +330,7 @@ def test_leakage_from_tracebacks(self):
330330
first_created = middle_objs - initial_objs
331331
gc.collect()
332332
second_created = len(gc.get_objects()) - middle_objs
333-
self.assert_(second_created - first_created < 10,
333+
self.assertTrue(second_created - first_created < 10,
334334
"first loop: %s, second loop: %s" % (first_created,
335335
second_created))
336336
tpool.killall()

0 commit comments

Comments
 (0)