chore(test): bltins arg pass,2 level comprehension,f_back,globals locals

Author: litlighilit

tests/asserts/bltins.py

@@ -0,0 +1,89 @@
+"""Assert-based tests for builtin call/argument passing.
+
+Rules: only builtin functions are tested; no user-defined functions;
+do not use argument unpacking (`*` or `**`).
+"""
+
+# dict and dict.fromkeys
+def test_init():
+  assert dict() == {}
+  #assert dict([('a', 1), ('b', 2)]) == {'a': 1, 'b': 2}
+  assert dict(a=1, b=2) == {'a': 1, 'b': 2}
+  assert dict.fromkeys([1, 2]) == {1: None, 2: None}
+  assert dict.fromkeys([1, 2], 0) == {1: 0, 2: 0}
+
+  # list
+  assert list() == []
+  assert list((1, 2, 3)) == [1, 2, 3]
+test_init()
+
+# numeric builtins: max, min
+def test_min_max():
+  assert max(1, 2, 3) == 3
+  assert max([1, 5, 3]) == 5
+  assert min([1, 0, -1]) == -1
+  # use builtin `abs` as a key function
+  assert max([-1, -2, 0], key=abs) == -2
+
+  # simple sanity checks combining builtin calls
+  s = set(dict.fromkeys((3, 1, 2)).keys())
+  assert s == {1, 2, 3}
+test_min_max()
+
+# Grouped tests using `def` (each function is called so asserts execute)
+def test_numeric_builtins():
+  # # pow with two and three args
+  # assert pow(2, 3) == 8
+  # assert pow(2, 3, 5) == 3
+
+  # # divmod and round
+  # assert divmod(7, 3) == (2, 1)
+  # assert round(2.5) in (2, 3)
+
+  # abs and built-in conversions
+  assert abs(-5) == 5
+  assert int('10') + 5 == 15
+
+
+def test_sequence_and_sorting():
+  # conversions and sorted results
+  assert list((4, 3, 2)) == [4, 3, 2]
+  assert tuple([1, 2]) == (1, 2)
+  assert set([1, 2, 2]) == {1, 2}
+  assert sorted([3, 1, 2]) == [1, 2, 3]
+
+  # reversed returns an iterator; collect via list()
+  assert list(reversed([1, 2, 3])) == [3, 2, 1]
+
+
+def test_dictionary_methods_and_lookup():
+  # dict creation and lookups
+  x = dict.fromkeys(['x', 'y'], 0)
+  assert x == {'x': 0, 'y': 0}
+  x2 = dict(a=1, b=2)
+  assert x2.get('a') == 1
+  x2.pop('a') == 1
+  # ensure pop removed key
+  assert 'a' not in x2
+
+
+
+def test_boolean_any_all_sum():
+  assert any([0, '', None, 1]) is True
+  assert all([1, True, 'nonempty']) is True
+  assert sum([1, 2, 3]) == 6
+
+
+def test_string_and_bytes():
+  assert str(123) == '123'
+  b = bytes([65, 66, 67])
+  assert b == b'ABC'
+
+
+# Call grouped tests so their asserts run
+test_numeric_builtins()
+test_sequence_and_sorting()
+test_dictionary_methods_and_lookup()
+test_boolean_any_all_sum()
+test_string_and_bytes()
+

tests/asserts/comprehension.py

@@ -7,4 +7,7 @@ def foo():
 
 for i in range(10):
     assert l[i] == i
+
+assert [i for j in [[1, 2]] for i in j] == [1, 2]
+
 print("ok")

tests/asserts/dict.py

@@ -0,0 +1,41 @@
+
+import xfail
+def test_dictionary_methods_and_lookup():
+	x2 = dict(a=1, b=2)
+	assert x2.pop('a') == 1
+	# ensure pop removed key
+	assert 'a' not in x2
+
+test_dictionary_methods_and_lookup()
+
+cnt = 0
+def key_error():
+  ori = dict(a=1, b=2)
+  x = ori.copy()
+  x.pop('a')
+  cnt += 1
+  assert len(ori) == 2, "dict.copy wrong"
+
+  assert 1000 == x.pop('a', 1000)
+  cnt += 1
+
+  x.pop('a')
+  cnt += 1
+
+xfail.xfail(key_error, KeyError)
+assert cnt == 2
+
+
+def test_dict_update():
+  d = {}
+  d.update(dict(a=1))
+  assert d == {'a': 1}
+
+  d.update(b=2)
+  assert d == {'a': 1, 'b': 2}
+
+  d.clear()
+  d.update([('a', 2)], b=1)
+  assert d == {'a': 2, 'b': 1}
+test_dict_update()
+

tests/asserts/localsglobals.py

@@ -0,0 +1,12 @@
+
+assert id(locals()) == id(globals())
+
+def f():
+    a = 123
+    assert id(locals()) != id(globals())
+    assert locals()['a'] == 123
+    assert 'a' in locals()
+    assert 'a' not in globals()
+
+f()
+

tests/asserts/oserr.py

@@ -0,0 +1,8 @@
+
+e=OSError()
+assert not hasattr(e, "characters_written")
+
+e.characters_written = 42
+assert e.characters_written == 42
+
+assert e.filename is None

tests/asserts/traceback.py

@@ -0,0 +1,13 @@
+
+def f():
+  raise ValueError
+
+g = None
+try: f()
+except ValueError as e: g = e
+
+tb = g.__traceback__
+nb = tb.tb_next.tb_frame.f_back
+assert nb is tb.tb_frame, nb
+
+