mirror of
https://github.com/wxWidgets/Phoenix.git
synced 2025-07-20 20:21:09 +02:00
95cafd1a3f
The convention when importing numpy is to use `import numpy as np` Fixes: unconventional-import-alias (ICN001) Ruff rule: https://docs.astral.sh/ruff/rules/unconventional-import-alias/
451 lines
12 KiB
Python
451 lines
12 KiB
Python
import unittest
|
|
from unittests import wtc
|
|
import wx
|
|
|
|
#---------------------------------------------------------------------------
|
|
|
|
class TestPoint(unittest.TestCase):
|
|
|
|
def test_default_ctor(self):
|
|
p = wx.Point()
|
|
self.assertTrue(p == (0,0))
|
|
|
|
def test_xy_ctor(self):
|
|
p = wx.Point(123,456)
|
|
|
|
def test_RealPoint_ctor(self):
|
|
p = wx.Point(wx.RealPoint(1.2, 2.9))
|
|
self.assertTrue(p == (1,3))
|
|
|
|
def test_copy_ctor(self):
|
|
p1 = wx.Point(3,4)
|
|
p2 = wx.Point(p1)
|
|
self.assertTrue(p1 is not p2)
|
|
self.assertTrue(p1 == p2)
|
|
|
|
def test_bogus_ctor1(self):
|
|
with self.assertRaises(TypeError):
|
|
p = wx.Point('fiddle-fadle')
|
|
|
|
def test_bogus_ctor2(self):
|
|
with self.assertRaises(TypeError):
|
|
p = wx.Point(1,2,3)
|
|
|
|
def test_seq_ctor(self):
|
|
p = wx.Point( [123,456] )
|
|
|
|
def test_numpy_ctor(self):
|
|
import numpy as np
|
|
a = np.array([123,456])
|
|
p = wx.Point(a)
|
|
|
|
|
|
def test_DefaultPosition(self):
|
|
wx.DefaultPosition
|
|
self.assertTrue(wx.DefaultPosition == (-1,-1))
|
|
|
|
def test_FullySpecified(self):
|
|
p = wx.Point(1,2)
|
|
self.assertTrue(p.IsFullySpecified())
|
|
p = wx.Point(-1,2)
|
|
self.assertTrue(not p.IsFullySpecified())
|
|
|
|
def test_xy(self):
|
|
p = wx.Point(2, 3)
|
|
self.assertTrue(p.x == 2 and p.y == 3)
|
|
p.x += 1
|
|
p.y += 2
|
|
self.assertTrue(p.x == 3 and p.y == 5)
|
|
self.assertTrue(p == (3,5))
|
|
|
|
def test_Get(self):
|
|
p = wx.Point(5,6)
|
|
self.assertTrue(type(p.Get()) == tuple)
|
|
self.assertTrue(p.Get() == (5,6))
|
|
|
|
def test_operators(self):
|
|
p1 = wx.Point(100, 500)
|
|
p2 = wx.Point(50, 100)
|
|
p1 == p2
|
|
p1 != p2
|
|
p = p1 + p2
|
|
p = p1 + wx.Size(5,5)
|
|
p = -p1
|
|
p = p1 - p2
|
|
p = p1 - wx.Size(5,5)
|
|
p = p1 * 5
|
|
#p = 5 * p1
|
|
p = p1 / 5
|
|
p1 += p2
|
|
p1 -= p2
|
|
|
|
def test_operators2(self):
|
|
p1 = wx.Point(4,5)
|
|
p2 = wx.Point(4,5)
|
|
p3 = wx.Point(9,9)
|
|
self.assertTrue(p1 == p2)
|
|
self.assertFalse(p1 != p2)
|
|
self.assertFalse(p1 == p3)
|
|
self.assertTrue(p1 != p3)
|
|
|
|
|
|
def test_magic(self):
|
|
p = wx.Point(5,6)
|
|
self.assertTrue(str(p) == "(5, 6)")
|
|
self.assertTrue(repr(p) == "wx.Point(5, 6)")
|
|
self.assertTrue(len(p) == 2)
|
|
x, y = p
|
|
self.assertTrue(x == 5 and y == 6)
|
|
p[0] += 1 # tests both getitem and setitem
|
|
p[1] += 2
|
|
self.assertTrue(p == (6,8))
|
|
with self.assertRaises(IndexError):
|
|
p[2]
|
|
|
|
def test_math(self):
|
|
p = wx.Point(4,6)
|
|
p1 = p + wx.Point(4,2)
|
|
p2 = p + (4,2)
|
|
p3 = p * 2
|
|
p4 = p / 2
|
|
p5 = p - wx.Point(4,2)
|
|
p6 = -p
|
|
|
|
self.assertTrue(isinstance(p1, wx.Point))
|
|
self.assertTrue(isinstance(p2, wx.Point))
|
|
self.assertTrue(isinstance(p3, wx.Point))
|
|
self.assertTrue(isinstance(p4, wx.Point))
|
|
self.assertTrue(isinstance(p5, wx.Point))
|
|
self.assertTrue(isinstance(p6, wx.Point))
|
|
|
|
self.assertEqual(p1, (8,8))
|
|
self.assertEqual(p2, (8,8))
|
|
self.assertEqual(p3, (8,12))
|
|
self.assertEqual(p4, (2,3))
|
|
self.assertEqual(p5, (0,4))
|
|
self.assertEqual(p6, (-4,-6))
|
|
|
|
|
|
def test_GetIM(self):
|
|
# Test the immutable version returned by GetIM
|
|
obj = wx.Point(1,2)
|
|
im = obj.GetIM()
|
|
assert isinstance(im, tuple)
|
|
assert im.x == obj.x
|
|
assert im.y == obj.y
|
|
obj2 = wx.Point(im)
|
|
assert obj == obj2
|
|
|
|
|
|
def test_converters(self):
|
|
# Ensure that other types that are sequence-like can't be
|
|
# auto-converted, the copy constructor is good-enough for testing this
|
|
with self.assertRaises(TypeError):
|
|
p = wx.Point(wx.Size(10,20))
|
|
|
|
def test_floatingMultiply(self):
|
|
v0 = wx.Point(3,4)
|
|
v1 = v0 * 4
|
|
v2 = v0 * 4.0
|
|
v3 = v0 * 4.4
|
|
v4 = v0 * 4.9
|
|
|
|
assert v1 == (12, 16)
|
|
assert v2 == (12, 16)
|
|
assert v3 == (13, 17)
|
|
assert v4 == (14, 19)
|
|
|
|
#---------------------------------------------------------------------------
|
|
|
|
|
|
class TestSize(unittest.TestCase):
|
|
|
|
def test_default_ctor(self):
|
|
s = wx.Size()
|
|
self.assertTrue(s == (0,0))
|
|
|
|
def test_wh_ctor(self):
|
|
s = wx.Size(100,200)
|
|
|
|
def test_copy_ctor(self):
|
|
s1 = wx.Size(100,200)
|
|
s2 = wx.Size(s1)
|
|
self.assertTrue(s1 is not s2)
|
|
self.assertTrue(s1 == s2)
|
|
|
|
def test_bogus_ctor(self):
|
|
with self.assertRaises(TypeError):
|
|
s = wx.Size("aa", "bb")
|
|
|
|
def test_DecBy(self):
|
|
s = wx.Size(100,100)
|
|
s.DecBy(wx.Point(5,5))
|
|
self.assertTrue(s == (95,95))
|
|
s.DecBy(wx.Size(5,5))
|
|
self.assertTrue(s == (90,90))
|
|
s.DecBy(5,5)
|
|
self.assertTrue(s == (85,85))
|
|
s.DecBy(5)
|
|
self.assertTrue(s == (80,80))
|
|
s.DecBy( (5,5) )
|
|
self.assertTrue(s == (75,75))
|
|
|
|
|
|
def test_IncBy(self):
|
|
s = wx.Size(50,50)
|
|
s.IncBy(wx.Point(5,5))
|
|
self.assertTrue(s == (55,55))
|
|
s.IncBy(wx.Size(5,5))
|
|
self.assertTrue(s == (60,60))
|
|
s.IncBy(5,5)
|
|
self.assertTrue(s == (65,65))
|
|
s.IncBy(5)
|
|
self.assertTrue(s == (70,70))
|
|
s.IncBy( (5,5) )
|
|
self.assertTrue(s == (75,75))
|
|
|
|
def test_DecTo(self):
|
|
s = wx.Size(5, 15)
|
|
s.DecTo( (10,10) )
|
|
self.assertTrue(s == (5,10))
|
|
|
|
def test_IncTo(self):
|
|
s = wx.Size(5, 15)
|
|
s.IncTo( (10,10) )
|
|
self.assertTrue(s == (10,15))
|
|
|
|
def test_properties(self):
|
|
s = wx.Size(23,34)
|
|
self.assertTrue(s.width == 23 and s.height == 34)
|
|
s.width += 1
|
|
s.height += 1
|
|
self.assertTrue(s == (24,35))
|
|
|
|
def test_operators(self):
|
|
s1 = wx.Size(100,200)
|
|
s2 = wx.Size(30,40)
|
|
s1 += s2
|
|
s1 -= s2
|
|
s1 *= 5
|
|
s1 /= 5
|
|
s1 == s2
|
|
s1 != s2
|
|
s = s1 * 5
|
|
#s = 5 * s1
|
|
s = s1 + s2
|
|
s = s1 - s2
|
|
s = s1 / 5
|
|
|
|
def test_DefaultSize(self):
|
|
ds = wx.DefaultSize
|
|
self.assertTrue(ds == (-1,-1))
|
|
|
|
def test_GetSet(self):
|
|
s = wx.Size(100,200)
|
|
t = s.Get()
|
|
self.assertTrue(type(t) == tuple)
|
|
self.assertTrue(t == (100,200))
|
|
s.Set(5,10)
|
|
self.assertTrue(s.Get() == (5,10))
|
|
|
|
def test_SetDefaults(self):
|
|
s = wx.Size(50, -1)
|
|
s.SetDefaults( (25,25) )
|
|
self.assertTrue(s == (50,25))
|
|
|
|
def test_FullySpecified(self):
|
|
self.assertTrue(wx.Size(40,50).IsFullySpecified())
|
|
self.assertTrue(not wx.Size(-1,50).IsFullySpecified())
|
|
self.assertTrue(not wx.Size(40,-1).IsFullySpecified())
|
|
|
|
def test_magic(self):
|
|
s = wx.Size(5,6)
|
|
self.assertTrue(str(s) == "(5, 6)")
|
|
self.assertTrue(repr(s) == "wx.Size(5, 6)")
|
|
self.assertTrue(len(s) == 2)
|
|
w, h = s
|
|
self.assertTrue(5 == 5 and h == 6)
|
|
s[0] += 1 # tests both getitem and setitem
|
|
s[1] += 2
|
|
self.assertTrue(s == (6,8))
|
|
with self.assertRaises(IndexError):
|
|
s[2]
|
|
|
|
|
|
def test_GetIM(self):
|
|
# Test the immutable version returned by GetIM
|
|
obj = wx.Size(1,2)
|
|
im = obj.GetIM()
|
|
assert isinstance(im, tuple)
|
|
assert im.width == obj.width
|
|
assert im.height == obj.height
|
|
obj2 = wx.Size(im)
|
|
assert obj == obj2
|
|
|
|
|
|
def test_converters(self):
|
|
# Ensure that other types that are sequence-like can't be
|
|
# auto-converted, the copy constructor is good-enough for testing this
|
|
with self.assertRaises(TypeError):
|
|
p = wx.Size(wx.Point(10,20))
|
|
|
|
|
|
def test_floatingMultiply(self):
|
|
v0 = wx.Size(3,4)
|
|
v1 = v0 * 4
|
|
v2 = v0 * 4.0
|
|
v3 = v0 * 4.4
|
|
v4 = v0 * 4.9
|
|
|
|
assert v1 == (12, 16)
|
|
assert v2 == (12, 16)
|
|
assert v3 == (13, 18)
|
|
assert v4 == (15, 20)
|
|
|
|
|
|
#---------------------------------------------------------------------------
|
|
|
|
|
|
class TestRealPoint(unittest.TestCase):
|
|
|
|
def test_default_ctor(self):
|
|
p = wx.RealPoint()
|
|
|
|
def test_xy_ctor(self):
|
|
p = wx.RealPoint(12.3, 34.5)
|
|
|
|
def test_Point_ctor(self):
|
|
p = wx.RealPoint(wx.Point(3,5))
|
|
p = wx.RealPoint( (3,5) )
|
|
|
|
def test_copy_ctor(self):
|
|
p1 = wx.RealPoint(12.3, 45.6)
|
|
p2 = wx.RealPoint(p1)
|
|
|
|
def test_properties(self):
|
|
p = wx.RealPoint(12.3, 45.6)
|
|
p.x += 2
|
|
p.y += 2
|
|
|
|
|
|
@unittest.skip("Fails: https://github.com/wxWidgets/Phoenix/issues/2070")
|
|
def test_GetIM(self):
|
|
# Test the immutable version returned by GetIM
|
|
obj = wx.RealPoint(1,2)
|
|
im = obj.GetIM()
|
|
assert isinstance(im, tuple)
|
|
assert im.x == obj.x
|
|
assert im.y == obj.y
|
|
obj2 = wx.RealPoint(im)
|
|
assert obj == obj2
|
|
|
|
|
|
def test_floatingMultiply(self):
|
|
v0 = wx.RealPoint(3,4)
|
|
v1 = v0 * 4
|
|
v2 = v0 * 4.0
|
|
v3 = v0 * 4.4
|
|
v4 = v0 * 4.9
|
|
|
|
assert v1 == (12.0, 16.0)
|
|
assert v2 == (12.0, 16.0)
|
|
assert round(v3.x, 2) == 13.20
|
|
assert round(v3.y, 2) == 17.60
|
|
assert round(v4.x, 2) == 14.70
|
|
assert round(v4.y, 2) == 19.60
|
|
|
|
|
|
#---------------------------------------------------------------------------
|
|
|
|
class TestRect(unittest.TestCase):
|
|
|
|
def test_default_ctor(self):
|
|
r = wx.Rect()
|
|
|
|
def test_xywh_ctor(self):
|
|
r = wx.Rect(1, 2, 3, 4)
|
|
|
|
def test_kwargs_ctor(self):
|
|
r1 = wx.Rect(x=1, y=2, width=3, height=4)
|
|
r2 = wx.Rect(width=3, height=4, x=1, y=2)
|
|
self.assertTrue(r1 == r2)
|
|
self.assertTrue(r2 == (1,2,3,4))
|
|
|
|
def test_possize_ctor(self):
|
|
r = wx.Rect(wx.Point(10,10), wx.Size(100,100))
|
|
self.assertTrue(r.width == 100 and r.height == 100)
|
|
self.assertTrue(r.x == 10 and r.y == 10)
|
|
self.assertTrue(r == wx.Rect(pos=(10,10), size=(100,100)))
|
|
|
|
def test_tlbr_ctor(self):
|
|
r = wx.Rect(topLeft=wx.Point(10,10), bottomRight=wx.Point(100,100))
|
|
self.assertTrue(r.width == 91 and r.height == 91)
|
|
self.assertTrue(r.bottomRight == wx.Point(100,100))
|
|
self.assertTrue(r.topLeft == wx.Point(10,10))
|
|
|
|
def test_tlbr_ctor2(self):
|
|
r = wx.Rect(wx.Point(10,10), wx.Point(100,100))
|
|
self.assertTrue(r.width == 91 and r.height == 91)
|
|
self.assertTrue(r.bottomRight == wx.Point(100,100))
|
|
self.assertTrue(r.topLeft == wx.Point(10,10))
|
|
|
|
def test_size_ctor(self):
|
|
r = wx.Rect(wx.Size(50,100))
|
|
self.assertTrue(r.width == 50 and r.height == 100)
|
|
self.assertTrue(r.x == 0 and r.y == 0)
|
|
|
|
def test_seq_ctor(self):
|
|
r1 = wx.Rect( [1,2,3,4] )
|
|
self.assertTrue(r1 == (1,2,3,4))
|
|
|
|
def test_numpy_ctor(self):
|
|
import numpy as np
|
|
r1 = wx.Rect( np.array([1,2,3,4]) )
|
|
self.assertTrue(r1 == (1,2,3,4))
|
|
|
|
|
|
def test_GetIM(self):
|
|
# Test the immutable version returned by GetIM
|
|
obj = wx.Rect(1,2,3,4)
|
|
im = obj.GetIM()
|
|
assert isinstance(im, tuple)
|
|
assert im.x == obj.x
|
|
assert im.y == obj.y
|
|
assert im.width == obj.width
|
|
assert im.height == obj.height
|
|
obj2 = wx.Rect(im)
|
|
assert obj == obj2
|
|
|
|
|
|
def test_converters(self):
|
|
# Ensure that other types that are sequence-like can't be
|
|
# auto-converted, the copy constructor is good-enough for testing this
|
|
with self.assertRaises(TypeError):
|
|
p = wx.Rect(wx.Colour(1,2,3,4))
|
|
|
|
# TODO: more tests!
|
|
|
|
|
|
|
|
#---------------------------------------------------------------------------
|
|
|
|
class intersectRect_Tests(wtc.WidgetTestCase):
|
|
def test_intersectRect01(self):
|
|
r1 = wx.Rect(0,0,10,10)
|
|
r2 = wx.Rect(50,50,10,10)
|
|
r3 = wx.IntersectRect(r1, r2)
|
|
self.assertEqual(r3, None)
|
|
|
|
def test_intersectRect02(self):
|
|
r1 = wx.Rect(0,0,55,55)
|
|
r2 = wx.Rect(50,50,10,10)
|
|
r3 = wx.IntersectRect(r1, r2)
|
|
self.assertEqual(r3, wx.Rect(50,50,5,5))
|
|
|
|
|
|
|
|
#---------------------------------------------------------------------------
|
|
|
|
if __name__ == '__main__':
|
|
unittest.main()
|