class TestArray:
def test_base(self):
v = Array()
assert type(v) == Array
def test_equal(self):
arr = Array()
other = Array()
for item in [1, "foo", Node(), Vector2()]:
arr.append(item)
other.append(item)
assert arr == other
bad = Array([0, 0, 0])
assert not arr == bad # Force use of __eq__
@pytest.mark.parametrize(
"arg",
[
None,
0,
"foo",
Vector2(),
Node(),
[1],
Array([1, 2]),
PoolByteArray([1]),
PoolIntArray([1]),
],
)
def test_bad_equal(self, arg):
arr = Array([1])
assert arr != arg
def test_add(self):
arr = Array([None])
arr += Array([1, "two"]) # __iadd__
assert arr == Array([None, 1, "two"])
arr2 = arr + Array([3]) # __add__
assert arr2 == Array([None, 1, "two", 3])
def test_add_with_non_array(self):
arr = Array([0])
arr += [1, "two"] # __iadd__
assert arr == Array([0, 1, "two"])
arr2 = arr + [3] # __add__
assert arr2 == Array([0, 1, "two", 3])
# Also test list's __iadd__
arr3 = ["-1"]
arr3 += arr
assert arr3 == ["-1", 0, 1, "two"]
# list.__add__ only works with other lists
with pytest.raises(TypeError):
["-1"] + arr
arr4 = ["-1"] + list(arr)
assert arr4 == ["-1", 0, 1, "two"]
@pytest.mark.parametrize("arg", [None, 0, "foo", Vector2(), Node()])
def test_bad_add(self, arg):
with pytest.raises(TypeError):
assert Array() + arg
def test_repr(self):
v = Array()
assert repr(v) == "<Array([])>"
v = Array([1, "foo", Vector2()])
assert repr(v) == "<Array([1, 'foo', <Vector2(x=0.0, y=0.0)>])>"
@pytest.mark.parametrize(
"arg",
[42, "dummy", Node(), Vector2(), [object()]])
def test_bad_instantiate(self, arg):
with pytest.raises(TypeError):
Array(arg)
@pytest.mark.parametrize(
"arg",
[
Array(),
PoolColorArray(),
PoolVector3Array(),
PoolVector2Array(),
PoolStringArray(),
PoolRealArray(),
PoolIntArray(),
PoolByteArray(),
[],
(),
[42, 43, 44],
("foo", "bar", "spam"),
(Node(), Resource(), Area2D()),
[Vector2(), Vector2(), Vector2()],
(Node(), Resource(), Area2D(), Vector2(), "foo",
0), # Enjoy the mix
],
)
def test_instantiate_from_copy(self, arg):
arr = Array(arg)
if hasattr(arg, "_gd_ptr"):
assert arr._gd_ptr != arg._gd_ptr
@pytest.mark.parametrize(
"args",
[
["append", type(None), ("bar", )],
["clear", type(None), ()],
["count", int, ("foo", )],
["empty", bool, ()],
["erase", type(None), ("foo", )],
["front", str, ()],
["back", str, ()],
["find", int, ("foo", 0)],
["find_last", int, ("foo", )],
["has", bool, ("foo", )],
["hash", int, ()],
["insert", type(None), (0, "bar")],
["invert", type(None), ()],
["pop_back", str, ()],
["pop_front", str, ()],
["push_back", type(None), ("bar", )],
["push_front", type(None), ("bar", )],
["resize", type(None), (2, )],
["rfind", int, ("foo", 0)],
["sort", type(None), ()],
# ['sort_custom', type(None), (obj, func)],
],
ids=lambda x: x[0],
)
def test_methods(self, args):
v = Array(["foo"])
# Don't test methods' validity but bindings one
field, ret_type, params = args
assert hasattr(v, field)
method = getattr(v, field)
assert callable(method)
ret = method(*params)
assert type(ret) == ret_type
def test_len(self):
v = Array()
assert len(v) == 0
v.append("foo")
assert len(v) == 1
def test_getitem(self):
v = Array(["foo", 0, Node(), 0.42])
assert v[0] == "foo"
assert v[1] == 0
assert v[-1] == 0.42
def test_getitem_slice(self):
v = Array(["foo", 0, Node()])
assert isinstance(v[:-1], Array)
assert v[1:] == Array([v[1], v[2]])
def test_outofrange_getitem(self):
v = Array(["foo", 0])
with pytest.raises(IndexError):
v[2]
def test_setitem(self):
v = Array(["foo", 0, Node()])
v[0] = "bar"
assert len(v) == 3
assert v[0] == "bar"
v[-1] = 4
assert len(v) == 3
assert v[2] == 4
def test_outofrange_setitem(self):
v = Array(["foo", 0])
with pytest.raises(IndexError):
v[2] = 42
def test_delitem(self):
v = Array(["foo", 0, Node()])
del v[0]
assert len(v) == 2
assert v[0] == 0
del v[-1]
assert len(v) == 1
v[0] == 0
def test_outofrange_delitem(self):
v = Array(["foo", 0])
with pytest.raises(IndexError):
del v[2]
def test_iter(self):
items = ["foo", 0, Node()]
v = Array(items)
items_from_v = [x for x in v]
assert items_from_v == items
def test_append(self):
items = [1, "foo", Node()]
v = Array()
for item in items:
v.append(item)
assert len(v) == 3
assert v == Array(items)
def test_keys(self):
v = Dictionary({'a': 1, 2: 'foo', 0.5: Vector2()})
keys = v.keys()
assert set(keys) == set(['a', 2, 0.5])
def test_bad_equal(self, arg):
arr = Transform2D(1, Vector2(1, 2))
assert arr != arg
def test_bad_equal(self, arg):
arr = Vector2(1, 2)
assert arr != arg
def test_contains(self):
v = Dictionary({'a': 1, 2: 'foo', 0.5: Vector2()})
assert 'a' in v
assert 'dummy' not in v
def test_bad_mult(self, arg):
with pytest.raises(TypeError):
Vector2(2, 3) * arg
def test_div(self, args):
param, result = args
calc = Vector2(2, 3) / param
assert calc == result
class BaseTestPoolArray:
def _expand_arg(self, arg):
return arg(self) if isfunction(arg) else arg
def test_base(self):
v = self.acls()
assert type(v) == self.acls
@pytest.mark.parametrize("arg", [Array, lambda s: s.acls, list])
def test_equal(self, arg):
arg = self._expand_arg(arg)
arr = self.acls()
other = arg()
for item in [self.vg() for _ in range(4)]:
arr.append(item)
other.append(item)
assert arr == other
bad = self.acls([self.vg()])
assert not arr == bad # Force use of __eq__
@pytest.mark.parametrize(
"arg",
[
None,
0,
"foo",
Vector2(),
Node(),
lambda s: s.vg(1),
lambda s: s.acls(s.vg(1)),
lambda s: Array(s.vg(1)),
],
)
def test_bad_equal(self, arg):
arg = self._expand_arg(arg)
arr = self.acls()
assert arr != arg
def test_add(self):
v0 = self.vg(1)
arr = self.acls(v0)
v1 = self.vg(2)
arr += self.acls(v1) # __iadd__
assert arr == self.acls(v0 + v1)
v2 = self.vg(1)
arr2 = arr + self.acls(v2) # __add__
assert arr2 == self.acls(v0 + v1 + v2)
def test_add_with_non_PoolBytearray(self):
v0 = self.vg(1)
arr = self.acls(v0)
v1 = self.vg(2)
arr += v1 # __iadd__
assert arr == self.acls(v0 + v1)
v2 = self.vg(1)
arr2 = arr + v2 # __add__
assert arr2 == self.acls(v0 + v1 + v2)
# Test __radd__ as well
v3 = self.vg(1)
arr3 = v3 + arr2
assert arr3 == self.acls(v3 + v0 + v1 + v2)
@pytest.mark.parametrize("arg", [None, 0, "foo", Vector2(), Node()])
def test_bad_add(self, arg):
with pytest.raises(TypeError):
assert self.acls() + arg
def test_repr(self):
name = self.acls.__name__
v = self.acls()
assert repr(v) == "<%s([])>" % name
items = self.vg(3)
v = self.acls(items)
assert repr(v) == "<%s(%s)>" % (name, items)
@pytest.mark.parametrize(
"arg",
[42, "dummy",
Node(),
Vector2(), [object()],
Array(["not", "bytes"])])
def test_bad_instantiate(self, arg):
with pytest.raises(TypeError):
PoolByteArray(arg)
@pytest.mark.parametrize("arg", [
lambda s: s.acls(), lambda s: Array(s.vg(2)), [], (), lambda s: s.vg(3)
])
def test_instantiate_from_copy(self, arg):
arg = self._expand_arg(arg)
arr = self.acls(arg)
if hasattr(arg, "_gd_ptr"):
assert arr._gd_ptr != arg._gd_ptr
@pytest.mark.parametrize(
"args",
[
["append", type(None), lambda s: (s.vg(), )],
["insert", type(None), lambda s: (0, s.vg())],
["push_back", type(None), lambda s: (s.vg(), )],
["resize", type(None), (2, )],
],
ids=lambda x: x[0],
)
def test_methods(self, args):
v = self.acls(self.vg(1))
# Don't test methods' validity but bindings one
field, ret_type, params = args
params = self._expand_arg(params)
assert hasattr(v, field)
method = getattr(v, field)
assert callable(method)
ret = method(*params)
assert type(ret) == ret_type
def test_len(self):
arr = self.acls()
assert len(arr) == 0
arr.append(self.vg())
assert len(arr) == 1
def test_getitem(self):
v = self.vg(3)
arr = self.acls(v)
assert arr[0] == v[0]
assert arr[1] == v[1]
assert arr[-1] == v[-1]
def test_getitem_slice(self):
arr = self.acls(self.vg(3))
assert isinstance(arr[:-1], self.acls)
assert arr[1:] == self.acls([arr[1], arr[2]])
def test_outofrange_getitem(self):
arr = self.acls(self.vg(2))
with pytest.raises(IndexError):
arr[2]
def test_setitem(self):
arr = self.acls(self.vg(3))
v = self.vg()
arr[0] = v
assert len(arr) == 3
assert arr[0] == v
arr[-1] = v
assert len(arr) == 3
assert arr[-1] == v
def test_outofrange_setitem(self):
arr = self.acls(self.vg(2))
v = self.vg()
with pytest.raises(IndexError):
arr[2] = v
def test_delitem(self):
items = self.vg(3)
arr = self.acls(items)
del arr[0]
assert len(arr) == 2
assert arr[0] == items[1]
assert arr[1] == items[2]
del arr[-1]
assert len(arr) == 1
assert arr[-1] == items[1]
def test_outofrange_delitem(self):
arr = self.acls(self.vg(2))
with pytest.raises(IndexError):
del arr[2]
def test_iter(self):
items = self.vg(3)
arr = self.acls(items)
items_from_v = [x for x in arr]
assert items_from_v == items
def test_append(self):
items = self.vg(3)
arr = self.acls()
for item in items:
arr.append(item)
assert len(arr) == 3
assert arr == self.acls(items)
def _ready(self):
self.direction = Vector2(1, 0)
self.ball_speed = DEFAULT_SPEED
self.stopped = False
self.screen_size = self.get_viewport_rect().size
self.set_process(True) # REMOVE ME
def test_keys(self):
v = Dictionary({"a": 1, 2: "foo", 0.5: Vector2()})
keys = v.keys()
assert set(keys) == set(["a", 2, 0.5])
class TestDictionary:
def test_base(self):
v = Dictionary()
assert type(v) == Dictionary
@pytest.mark.xfail(
reason="Godot Dictionary equal does lame comparison by pointer so far..."
)
def test_equal(self):
arr = Dictionary()
other = Dictionary()
for key, value in [("a", 1), ("b", "foo"), ("c", Node()), ("d", Vector2())]:
other[key] = arr[key] = value
assert arr == other
bad = Dictionary({"a": 1})
assert not arr == bad # Force use of __eq__
@pytest.mark.parametrize(
"arg", [None, 0, "foo", Vector2(), Node(), {"a": 1}, Dictionary({"b": 2})]
)
def test_bad_equal(self, arg):
arr = Dictionary({"a": 1})
assert arr != arg
def test_repr(self):
v = Dictionary()
assert repr(v) == "<Dictionary({})>"
v = Dictionary({"a": 1, 2: "foo", 0.5: Vector2()})
assert repr(v).startswith("<Dictionary({")
for item in ["'a': 1", "2: 'foo'", "0.5: <Vector2(x=0.0, y=0.0)>"]:
assert item in repr(v)
@pytest.mark.parametrize(
"arg",
[42, "dummy", Node(), Vector2(), [object()], {object(): 1}, {1: object()}],
)
def test_bad_instantiate(self, arg):
with pytest.raises(TypeError):
Dictionary(arg)
@pytest.mark.parametrize(
"arg",
[
Dictionary(),
{},
{"a": 1, 2: "foo", 0.5: Vector2()},
Dictionary({"a": 1, 2: "foo", 0.5: Vector2()}),
],
)
def test_instantiate_from_copy(self, arg):
arr = Dictionary(arg)
if hasattr(arg, "_gd_ptr"):
assert arr._gd_ptr != arg._gd_ptr
def test_len(self):
v = Dictionary()
assert len(v) == 0
v["foo"] = "bar"
assert len(v) == 1
def test_getitem(self):
v = Dictionary({"a": 1, 2: "foo", 0.5: Vector2()})
assert v["a"] == 1
assert v[0.5] == Vector2()
# Missing items are stored as None
assert v["dummy"] is None
# Cannot store non Godot types
with pytest.raises(TypeError):
v[object()]
def test_setitem(self):
v = Dictionary({"a": 1, 2: "foo", 0.5: Vector2()})
v[0] = "bar"
assert len(v) == 4
assert v[0] == "bar"
v["a"] = 4
assert len(v) == 4
assert v["a"] == 4
# Cannot store non Godot types
with pytest.raises(TypeError):
v[object()] = 4
with pytest.raises(TypeError):
v[4] = object()
def test_delitem(self):
v = Dictionary({"a": 1, 2: "foo", 0.5: Vector2()})
del v["a"]
assert len(v) == 2
del v[0.5]
assert len(v) == 1
v[2] == "foo"
# Missing items can be deleted without error
del v["missing"]
# Cannot store non Godot types
with pytest.raises(TypeError):
del v[object()]
def test_update(self):
v = Dictionary({"a": 1, "b": 2, "c": 3})
v.update({"a": "one", "d": "four"})
v.update(Dictionary({"b": "two", "e": "five"}))
assert set(v.keys()) == {"a", "b", "c", "d", "e"}
assert set(v.values()) == {"one", "two", 3, "four", "five"}
def test_contains(self):
v = Dictionary({"a": 1, 2: "foo", 0.5: Vector2()})
assert "a" in v
assert "dummy" not in v
def test_iter(self):
v = Dictionary({"a": 1, 2: "foo", 0.5: Vector2()})
items = ["a", 2, 0.5]
items_from_v = [x for x in v]
assert set(items_from_v) == set(items)
def test_keys(self):
v = Dictionary({"a": 1, 2: "foo", 0.5: Vector2()})
keys = v.keys()
assert set(keys) == set(["a", 2, 0.5])
def test_values(self):
v = Dictionary({"a": 1, 2: "foo"})
values = v.values()
assert set(values) == set([1, "foo"])
def test_items(self):
v = Dictionary({"a": 1, 2: "foo"})
items = v.items()
assert set(items) == set([("a", 1), (2, "foo")])
def test_empty_and_clear(self):
v = Dictionary({"a": 1, 2: "foo"})
assert not v.empty()
v.clear()
assert len(v) == 0
assert v.empty()
def test_in(self):
v = Dictionary({"a": 1, 2: "foo"})
assert "a" in v
assert "dummy" not in v
def test_hash(self):
v = Dictionary({"a": 1, 2: "foo"})
v.hash()
def test_has_all(self):
v = Dictionary({"a": 1, 2: "foo", None: None})
elems = Array(["a", None])
assert v.has_all(elems)
bad_elems = Array(["a", 42])
assert not v.has_all(bad_elems)
def test_to_json(self):
v = Dictionary({"a": 1, "b": "foo"})
jsoned = v.to_json()
v2 = json.loads(jsoned)
assert v2 == {"a": 1, "b": "foo"}
assert json
def test_iter(self):
v = Dictionary({"a": 1, 2: "foo", 0.5: Vector2()})
items = ["a", 2, 0.5]
items_from_v = [x for x in v]
assert set(items_from_v) == set(items)
def test_contains(self):
v = Dictionary({"a": 1, 2: "foo", 0.5: Vector2()})
assert "a" in v
assert "dummy" not in v
def test_repr(self):
v = Array()
assert repr(v) == "<Array([])>"
v = Array([1, "foo", Vector2()])
assert repr(v) == "<Array([1, 'foo', <Vector2(x=0.0, y=0.0)>])>"
def test_bad_div(self, arg):
with pytest.raises(TypeError):
Vector2(2, 3) / arg
class TestRect2:
def test_base(self):
v = Rect2(4, 3, 2, 1)
assert type(v) == Rect2
v2 = Rect2(1, 2, 3, 4)
assert type(v) == Rect2
assert v2 == Rect2(1, 2, 3, 4)
assert v != v2
def test_repr(self):
v = Rect2(1, 2)
assert repr(v) == '<Rect2(1, 2, 0, 0)>'
def test_instantiate(self):
# Can build it with int or float or nothing
msg_tmpl = "%s vs (expected) %s (args=%s)"
for args, expected_pos, expected_size in ([(),
Vector2(0, 0),
Vector2(0, 0)], [
(0.5, 0.5),
Vector2(0.5, 0.5),
Vector2(0, 0)
], [(1, 2, 1, 2),
Vector2(1, 2),
Vector2(1, 2)]):
v = Rect2(*args)
assert v.position == expected_pos, msg_tmpl % (v.position,
expected_pos, args)
assert v.size == expected_size, msg_tmpl % (v.size, expected_size,
args)
with pytest.raises(TypeError):
Rect2("a", 2, 3, 4)
with pytest.raises(TypeError):
Rect2(1, "b", 3, 4)
with pytest.raises(TypeError):
Rect2(1, 2, "c", 4)
with pytest.raises(TypeError):
Rect2(1, 2, 3, "d")
with pytest.raises(TypeError):
Rect2(None, 2)
@pytest.mark.parametrize('args', [
['clip', Rect2, (Rect2(), )],
['encloses', bool, (Rect2(), )],
['expand', Rect2, (Vector2(), )],
['get_area', float, ()],
['grow', Rect2, (0.5, )],
['has_no_area', bool, ()],
['has_point', bool, (Vector2(), )],
['intersects', bool, (Rect2(), )],
['merge', Rect2, (Rect2(), )],
],
ids=lambda x: x[0])
def test_methods(self, args):
v = Rect2()
# Don't test methods' validity but bindings one
field, ret_type, params = args
assert hasattr(v, field)
method = getattr(v, field)
assert callable(method)
ret = method(*params)
assert type(ret) == ret_type
@pytest.mark.parametrize('args', [
('position', Vector2),
('size', Vector2),
],
ids=lambda x: x[0])
def test_properties(self, args):
v = Rect2()
field, ret_type = args
assert hasattr(v, field)
field_val = getattr(v, field)
assert type(field_val) == ret_type
for val in (Vector2(), Vector2(0.1, -0.1)):
setattr(v, field, val)
field_val = getattr(v, field)
assert field_val == val
@pytest.mark.parametrize('args', [
('position', 'dummy'),
('size', 'dummy'),
('position', None),
('size', None),
('position', 42),
('size', 42),
],
ids=lambda x: x[0])
def test_bad_properties(self, args):
v = Rect2()
field, bad_value = args
with pytest.raises(TypeError):
setattr(v, field, bad_value)
def test_equal(self):
arr = Rect2(0.1, 1, 2, 3)
other = Rect2(0.1, 1, 2, 3)
assert arr == other
bad = Rect2(0.1, 1, 2, 4)
assert not arr == bad # Force use of __eq__
@pytest.mark.parametrize('arg', [
None,
0,
'foo',
Rect2(0.1, 1, 2, 4),
])
def test_bad_equal(self, arg):
arr = Rect2(0.1, 1, 2, 3)
assert arr != arg
def test_zero_div(self, arg):
with pytest.raises(ZeroDivisionError):
Vector2(2, 3) / arg
def test_bad_properties(self, args):
v = Vector2()
field, bad_value = args
with pytest.raises(TypeError):
setattr(v, field, bad_value)
def test_mult(self, args):
param, result = args
calc = Vector2(2, 3) * param
assert calc == result
def test_add(self, args):
param, result = args
calc = Vector2(2, 3) + param
assert calc == result
def test_equal(self):
arr = Vector2(1, 2)
other = Vector2(1, 2)
assert arr == other
bad = Vector2(1, 3)
assert not arr == bad # Force use of __eq__
def test_repr(self):
v = Vector2(1, 2)
assert repr(v) == "<Vector2(x=1.0, y=2.0)>"
class TestVector2:
def test_base(self):
v = Vector2()
assert type(v) == Vector2
v2 = Vector2(1, -2)
assert type(v) == Vector2
assert v2 == Vector2(1, -2)
assert v != v2
def test_repr(self):
v = Vector2(1, 2)
assert repr(v) == "<Vector2(x=1.0, y=2.0)>"
def test_instantiate(self):
# Can build it with int or float or nothing
msg_tmpl = "%s vs (expected) %s (args=%s)"
for args, expected_x, expected_y in (
[(), 0, 0],
[(0.5, 0.5), 0.5, 0.5],
[(1, 2), 1, 2],
[(1, ), 1, 0],
):
v = Vector2(*args)
assert v.x == expected_x, msg_tmpl % (v.x, expected_x, args)
assert v.y == expected_y, msg_tmpl % (v.y, expected_y, args)
assert v.width == expected_x, msg_tmpl % (v.width, expected_y,
args)
assert v.height == expected_y, msg_tmpl % (v.height, expected_x,
args)
with pytest.raises(TypeError):
Vector2("a", 2)
with pytest.raises(TypeError):
Vector2("a", 2)
with pytest.raises(TypeError):
Vector2(1, "b")
with pytest.raises(TypeError):
Vector2(None, 2)
@pytest.mark.parametrize(
"args",
[
["abs", Vector2, ()],
["angle", float, ()],
["angle_to", float, (Vector2(), )],
["angle_to_point", float, (Vector2(), )],
["clamped", Vector2, (0.5, )],
[
"cubic_interpolate", Vector2,
(Vector2(), Vector2(), Vector2(), 0.5)
],
["distance_squared_to", float, (Vector2(), )],
["distance_to", float, (Vector2(), )],
["dot", float, (Vector2(), )],
["floor", Vector2, ()],
["aspect", float, ()],
["length", float, ()],
["length_squared", float, ()],
["linear_interpolate", Vector2, (Vector2(), 0.5)],
["normalized", Vector2, ()],
["reflect", Vector2, (Vector2(), )],
["rotated", Vector2, (0.5, )],
["slide", Vector2, (Vector2(), )],
["snapped", Vector2, (Vector2(), )],
["tangent", Vector2, ()],
],
ids=lambda x: x[0],
)
def test_methods(self, args):
v = Vector2()
# Don't test methods' validity but bindings one
field, ret_type, params = args
assert hasattr(v, field)
method = getattr(v, field)
assert callable(method)
ret = method(*params)
assert type(ret) == ret_type
@pytest.mark.parametrize(
"args",
[("height", float), ("width", float), ("x", float), ("y", float)],
ids=lambda x: x[0],
)
def test_properties(self, args):
v = Vector2()
field, ret_type = args
assert hasattr(v, field)
field_val = getattr(v, field)
assert type(field_val) == ret_type
for val in (0, 10, 10., 42.5):
setattr(v, field, val)
field_val = getattr(v, field)
assert field_val == val
@pytest.mark.parametrize(
"args",
[("height", "NaN"), ("width", "NaN"), ("x", "NaN"), ("y", "NaN")],
ids=lambda x: x[0],
)
def test_bad_properties(self, args):
v = Vector2()
field, bad_value = args
with pytest.raises(TypeError):
setattr(v, field, bad_value)
def test_unary(self):
v = Vector2(1, 2)
v2 = -v
assert v2.x == -1
assert v2.y == -2
v3 = +v
assert v3.x == 1
assert v3.y == 2
v = Vector2(1.5, 2.5)
v2 = -v
assert v2.x == -1.5
assert v2.y == -2.5
v3 = +v
assert v3.x == 1.5
assert v3.y == 2.5
@pytest.mark.parametrize(
"args",
[
(Vector2(0, 0), Vector2(2, 3)),
(Vector2(3, 2), Vector2(5, 5)),
(Vector2(-1, -4), Vector2(1, -1)),
],
ids=lambda x: x[0],
)
def test_add(self, args):
param, result = args
calc = Vector2(2, 3) + param
assert calc == result
@pytest.mark.parametrize(
"args",
[
(Vector2(0, 0), Vector2(2, 3)),
(Vector2(3, 2), Vector2(-1, 1)),
(Vector2(-1, -1), Vector2(3, 4)),
],
ids=lambda x: x[0],
)
def test_sub(self, args):
param, result = args
calc = Vector2(2, 3) - param
assert calc == result
@pytest.mark.parametrize("arg", [None, 1, "dummy"], ids=lambda x: x[0])
def test_bad_add(self, arg):
with pytest.raises(TypeError):
Vector2(2, 3) + arg
@pytest.mark.parametrize("arg", [None, 1, "dummy"], ids=lambda x: x[0])
def test_bad_sub(self, arg):
with pytest.raises(TypeError):
Vector2(2, 3) - arg
@pytest.mark.parametrize("arg", [None, "dummy"], ids=lambda x: x[0])
def test_bad_div(self, arg):
with pytest.raises(TypeError):
Vector2(2, 3) / arg
@pytest.mark.parametrize(
"arg", [0, Vector2(0, 1),
Vector2(1, 0), Vector2(0, 0)],
ids=lambda x: x[0])
def test_zero_div(self, arg):
with pytest.raises(ZeroDivisionError):
Vector2(2, 3) / arg
@pytest.mark.parametrize("arg", [None, "dummy"], ids=lambda x: x[0])
def test_bad_mult(self, arg):
with pytest.raises(TypeError):
Vector2(2, 3) * arg
@pytest.mark.parametrize(
"args",
[
(0, Vector2(0, 0)),
(1, Vector2(2, 3)),
(2.5, Vector2(5, 7.5)),
(Vector2(1, 1), Vector2(2, 3)),
(Vector2(2, 3), Vector2(4, 9)),
],
ids=lambda x: x[0],
)
def test_mult(self, args):
param, result = args
calc = Vector2(2, 3) * param
assert calc == result
@pytest.mark.parametrize(
"args",
[
(1, Vector2(2, 3)),
(.5, Vector2(4, 6)),
(2, Vector2(1, 1.5)),
(Vector2(1, 1), Vector2(2, 3)),
(Vector2(2, 3), Vector2(1, 1)),
],
ids=lambda x: x[0],
)
def test_div(self, args):
param, result = args
calc = Vector2(2, 3) / param
assert calc == result
def test_equal(self):
arr = Vector2(1, 2)
other = Vector2(1, 2)
assert arr == other
bad = Vector2(1, 3)
assert not arr == bad # Force use of __eq__
@pytest.mark.parametrize("arg", [None, 0, "foo", Vector2(1, 3)])
def test_bad_equal(self, arg):
arr = Vector2(1, 2)
assert arr != arg
def test_sub(self, args):
param, result = args
calc = Vector2(2, 3) - param
assert calc == result
def test_iter(self):
v = Dictionary({'a': 1, 2: 'foo', 0.5: Vector2()})
items = ['a', 2, 0.5]
items_from_v = [x for x in v]
assert set(items_from_v) == set(items)
def test_bad_add(self, arg):
with pytest.raises(TypeError):
Vector2(2, 3) + arg
class TestDictionary:
def test_base(self):
v = Dictionary()
assert type(v) == Dictionary
@pytest.mark.xfail(
reason="Godot Dictionary equal does lame comparison by pointer so far..."
)
def test_equal(self):
arr = Dictionary()
other = Dictionary()
for key, value in [('a', 1), ('b', 'foo'), ('c', Node()),
('d', Vector2())]:
other[key] = arr[key] = value
assert arr == other
bad = Dictionary({'a': 1})
assert not arr == bad # Force use of __eq__
@pytest.mark.parametrize('arg', [
None,
0,
'foo',
Vector2(),
Node(),
{
'a': 1
},
Dictionary({'b': 2}),
])
def test_bad_equal(self, arg):
arr = Dictionary({'a': 1})
assert arr != arg
def test_repr(self):
v = Dictionary()
assert repr(v) == '<Dictionary({})>'
v = Dictionary({'a': 1, 2: 'foo', 0.5: Vector2()})
assert repr(v).startswith("<Dictionary({")
for item in ["'a': 1", "2: 'foo'", "0.5: <Vector2(x=0.0, y=0.0)>"]:
assert item in repr(v)
@pytest.mark.parametrize('arg', [
42, 'dummy',
Node(),
Vector2(), [object()], {
object(): 1
}, {
1: object()
}
])
def test_bad_instantiate(self, arg):
with pytest.raises(TypeError):
Dictionary(arg)
@pytest.mark.parametrize('arg', [
Dictionary(), {}, {
'a': 1,
2: 'foo',
0.5: Vector2()
},
Dictionary({
'a': 1,
2: 'foo',
0.5: Vector2()
})
])
def test_instantiate_from_copy(self, arg):
arr = Dictionary(arg)
if hasattr(arg, '_gd_ptr'):
assert arr._gd_ptr != arg._gd_ptr
def test_len(self):
v = Dictionary()
assert len(v) == 0
v['foo'] = 'bar'
assert len(v) == 1
def test_getitem(self):
v = Dictionary({'a': 1, 2: 'foo', 0.5: Vector2()})
assert v['a'] == 1
assert v[0.5] == Vector2()
# Missing items are stored as None
assert v['dummy'] is None
# Cannot store non Godot types
with pytest.raises(TypeError):
v[object()]
def test_setitem(self):
v = Dictionary({'a': 1, 2: 'foo', 0.5: Vector2()})
v[0] = 'bar'
assert len(v) == 4
assert v[0] == 'bar'
v['a'] = 4
assert len(v) == 4
assert v['a'] == 4
# Cannot store non Godot types
with pytest.raises(TypeError):
v[object()] = 4
with pytest.raises(TypeError):
v[4] = object()
def test_delitem(self):
v = Dictionary({'a': 1, 2: 'foo', 0.5: Vector2()})
del v['a']
assert len(v) == 2
del v[0.5]
assert len(v) == 1
v[2] == 'foo'
# Missing items can be deleted without error
del v['missing']
# Cannot store non Godot types
with pytest.raises(TypeError):
del v[object()]
def test_contains(self):
v = Dictionary({'a': 1, 2: 'foo', 0.5: Vector2()})
assert 'a' in v
assert 'dummy' not in v
def test_iter(self):
v = Dictionary({'a': 1, 2: 'foo', 0.5: Vector2()})
items = ['a', 2, 0.5]
items_from_v = [x for x in v]
assert set(items_from_v) == set(items)
def test_keys(self):
v = Dictionary({'a': 1, 2: 'foo', 0.5: Vector2()})
keys = v.keys()
assert set(keys) == set(['a', 2, 0.5])
def test_values(self):
v = Dictionary({'a': 1, 2: 'foo'})
values = v.values()
assert set(values) == set([1, 'foo'])
def test_items(self):
v = Dictionary({'a': 1, 2: 'foo'})
items = v.items()
assert set(items) == set([('a', 1), (2, 'foo')])
def test_empty_and_clear(self):
v = Dictionary({'a': 1, 2: 'foo'})
assert not v.empty()
v.clear()
assert len(v) == 0
assert v.empty()
def test_in(self):
v = Dictionary({'a': 1, 2: 'foo'})
assert 'a' in v
assert 'dummy' not in v
def test_hash(self):
v = Dictionary({'a': 1, 2: 'foo'})
v.hash()
def test_has_all(self):
v = Dictionary({'a': 1, 2: 'foo', None: None})
elems = Array(['a', None])
assert v.has_all(elems)
bad_elems = Array(['a', 42])
assert not v.has_all(bad_elems)
def test_to_json(self):
v = Dictionary({'a': 1, 'b': 'foo'})
jsoned = v.to_json()
v2 = json.loads(jsoned)
assert v2 == {'a': 1, 'b': 'foo'}
assert json
def test_bad_sub(self, arg):
with pytest.raises(TypeError):
Vector2(2, 3) - arg
def test_repr(self):
v = Transform2D(1, Vector2(1, 2))
assert repr(v).startswith('<Transform2D(')
def test_equal(self):
arr = Transform2D(1, Vector2(1, 2))
other = Transform2D(1, Vector2(1, 2))
assert arr == other
bad = Transform2D(1, Vector2(1, 3))
assert not arr == bad # Force use of __eq__