368 lines
11 KiB
Python
368 lines
11 KiB
Python
#!/usr/bin/env python
|
|
|
|
from efl import evas
|
|
import unittest
|
|
|
|
|
|
class TestRectBasics(unittest.TestCase):
|
|
def _test_values(self, r):
|
|
self.assertEqual(r.x, 1)
|
|
self.assertEqual(r.y, 2)
|
|
self.assertEqual(r.w, 3)
|
|
self.assertEqual(r.h, 4)
|
|
|
|
def testConstructorList(self):
|
|
r = evas.Rect(1, 2, 3, 4)
|
|
self._test_values(r)
|
|
|
|
def testConstructorTuple(self):
|
|
r = evas.Rect((1, 2, 3, 4))
|
|
self._test_values(r)
|
|
|
|
def testConstructorRect(self):
|
|
r = evas.Rect(evas.Rect(1, 2, 3, 4))
|
|
self._test_values(r)
|
|
|
|
def testConstructorKeywordsExplicit1(self):
|
|
r = evas.Rect(x=1, y=2, w=3, h=4)
|
|
self._test_values(r)
|
|
|
|
def testConstructorKeywordsExplicit2(self):
|
|
r = evas.Rect(left=1, top=2, width=3, height=4)
|
|
self._test_values(r)
|
|
|
|
def testConstructorKeywordsExplicit3(self):
|
|
r = evas.Rect(left=1, right=4, top=2, bottom=6)
|
|
self._test_values(r)
|
|
|
|
def testConstructorKeywordsExplicit4(self):
|
|
r = evas.Rect(right=4, bottom=6, width=3, height=4)
|
|
self._test_values(r)
|
|
|
|
def testConstructorKeywordsPosSize(self):
|
|
r = evas.Rect(pos=(1, 2), size=(3, 4))
|
|
self._test_values(r)
|
|
|
|
def testConstructorKeywordsGeometry(self):
|
|
r = evas.Rect(geometry=(1, 2, 3, 4))
|
|
self._test_values(r)
|
|
|
|
def testConstructorKeywordsRect(self):
|
|
r = evas.Rect(rect=evas.Rect(1, 2, 3, 4))
|
|
self._test_values(r)
|
|
|
|
|
|
class TestRectOperations(unittest.TestCase):
|
|
def setUp(self):
|
|
self.r = evas.Rect(10, 20, 30, 40)
|
|
|
|
def testContains(self):
|
|
r2 = evas.Rect(11, 21, 5, 5)
|
|
self.assertEqual(r2 in self.r, True)
|
|
|
|
def testContainsExactly(self):
|
|
r2 = evas.Rect(self.r)
|
|
self.assertEqual(r2 in self.r, True)
|
|
|
|
def testContainsLarger(self):
|
|
r2 = evas.Rect(0, 0, 100, 100)
|
|
self.assertEqual(r2 in self.r, False)
|
|
|
|
def testContainsOverlap1(self):
|
|
r2 = evas.Rect(0, 0, 20, 30)
|
|
self.assertEqual(r2 in self.r, False)
|
|
|
|
def testContainsOverlap2(self):
|
|
r2 = evas.Rect(15, 25, 50, 50)
|
|
self.assertEqual(r2 in self.r, False)
|
|
|
|
def testContainsTuple(self):
|
|
self.assertEqual((11, 21, 5, 5) in self.r, True)
|
|
|
|
def testContainsTupleLarger(self):
|
|
self.assertEqual((0, 0, 100, 100) in self.r, False)
|
|
|
|
def testContainsPoint(self):
|
|
self.assertEqual((15, 25) in self.r, True)
|
|
|
|
def testContainsPointNo(self):
|
|
self.assertEqual((0, 0) in self.r, False)
|
|
|
|
def testEqual(self):
|
|
self.assertEqual(self.r == self.r, True)
|
|
|
|
def testEqualOther(self):
|
|
self.assertEqual(self.r == evas.Rect(self.r), True)
|
|
|
|
def testEqualTuple(self):
|
|
self.assertEqual(self.r == (10, 20, 30, 40), True)
|
|
|
|
def testEqualOtherNo(self):
|
|
self.assertEqual(self.r == evas.Rect(1, 2, 3, 4), False)
|
|
|
|
def testEqualTupleNo(self):
|
|
self.assertEqual(self.r == (1, 2, 3, 4), False)
|
|
|
|
def testNotEqual(self):
|
|
self.assertEqual(self.r != self.r, False)
|
|
|
|
def testNotEqualOther(self):
|
|
self.assertEqual(self.r != evas.Rect(self.r), False)
|
|
|
|
def testNotEqualTuple(self):
|
|
self.assertEqual(self.r != (10, 20, 30, 40), False)
|
|
|
|
def testNotEqualOtherNo(self):
|
|
self.assertEqual(self.r != evas.Rect(1, 2, 3, 4), True)
|
|
|
|
def testNotEqualTupleNo(self):
|
|
self.assertEqual(self.r != (1, 2, 3, 4), True)
|
|
|
|
def testNormalize(self):
|
|
r2 = evas.Rect(left=10, right=0, top=20, bottom=0)
|
|
self.assertEqual(r2.left, 10)
|
|
self.assertEqual(r2.right, 0)
|
|
self.assertEqual(r2.top, 20)
|
|
self.assertEqual(r2.bottom, 0)
|
|
self.assertEqual(r2.w, -10)
|
|
self.assertEqual(r2.h, -20)
|
|
r2.normalize()
|
|
self.assertEqual(r2.left, 0)
|
|
self.assertEqual(r2.right, 10)
|
|
self.assertEqual(r2.top, 0)
|
|
self.assertEqual(r2.bottom, 20)
|
|
self.assertEqual(r2.w, 10)
|
|
self.assertEqual(r2.h, 20)
|
|
|
|
def testNonZero(self):
|
|
self.assertEqual(bool(self.r), True)
|
|
|
|
def testNonZero2(self):
|
|
self.assertEqual(bool(evas.Rect(0, 0, 0, 0)), False)
|
|
|
|
|
|
class TestRectIntercepts(unittest.TestCase):
|
|
def setUp(self):
|
|
self.r = evas.Rect(0, 0, 10, 10)
|
|
|
|
def testOver(self):
|
|
r2 = evas.Rect(self.r)
|
|
self.assert_(self.r.intercepts(r2))
|
|
|
|
def testInterceptTopLeft(self):
|
|
r2 = evas.Rect(-5, -5, 10, 10)
|
|
self.assert_(self.r.intercepts(r2))
|
|
|
|
def testInterceptTopRight(self):
|
|
r2 = evas.Rect(5, -5, 10, 10)
|
|
self.assert_(self.r.intercepts(r2))
|
|
|
|
def testInterceptBottomLeft(self):
|
|
r2 = evas.Rect(-5, 5, 10, 10)
|
|
self.assert_(self.r.intercepts(r2))
|
|
|
|
def testInterceptBottomRight(self):
|
|
r2 = evas.Rect(5, 5, 10, 10)
|
|
self.assert_(self.r.intercepts(r2))
|
|
|
|
def testInterceptLeft1(self):
|
|
r2 = evas.Rect(-5, 0, 10, 10)
|
|
self.assert_(self.r.intercepts(r2))
|
|
|
|
def testInterceptLeft2(self):
|
|
r2 = evas.Rect(-5, 2, 10, 5)
|
|
self.assert_(self.r.intercepts(r2))
|
|
|
|
def testInterceptLeft3(self):
|
|
r2 = evas.Rect(-5, 5, 30, 5)
|
|
self.assert_(self.r.intercepts(r2))
|
|
|
|
def testInterceptRight1(self):
|
|
r2 = evas.Rect(5, 0, 10, 10)
|
|
self.assert_(self.r.intercepts(r2))
|
|
|
|
def testInterceptRight2(self):
|
|
r2 = evas.Rect(5, 2, 10, 5)
|
|
self.assert_(self.r.intercepts(r2))
|
|
|
|
def testInterceptRight3(self):
|
|
r2 = evas.Rect(5, 5, 30, 5)
|
|
self.assert_(self.r.intercepts(r2))
|
|
|
|
def testInterceptTop1(self):
|
|
r2 = evas.Rect(0, -5, 10, 10)
|
|
self.assert_(self.r.intercepts(r2))
|
|
|
|
def testInterceptTop2(self):
|
|
r2 = evas.Rect(2, -5, 5, 10)
|
|
self.assert_(self.r.intercepts(r2))
|
|
|
|
def testInterceptTop3(self):
|
|
r2 = evas.Rect(5, -5, 5, 30)
|
|
self.assert_(self.r.intercepts(r2))
|
|
|
|
def testInterceptBottom1(self):
|
|
r2 = evas.Rect(0, 5, 10, 10)
|
|
self.assert_(self.r.intercepts(r2))
|
|
|
|
def testInterceptBottom2(self):
|
|
r2 = evas.Rect(2, 5, 5, 10)
|
|
self.assert_(self.r.intercepts(r2))
|
|
|
|
def testInterceptBottom3(self):
|
|
r2 = evas.Rect(5, 5, 5, 30)
|
|
self.assert_(self.r.intercepts(r2))
|
|
|
|
def testNoIntercept1(self):
|
|
r2 = evas.Rect(-10, -10, 5, 5)
|
|
self.assert_(not self.r.intercepts(r2))
|
|
|
|
def testNoIntercept2(self):
|
|
r2 = evas.Rect(0, -10, 5, 5)
|
|
self.assert_(not self.r.intercepts(r2))
|
|
|
|
def testNoIntercept3(self):
|
|
r2 = evas.Rect(10, -10, 5, 5)
|
|
self.assert_(not self.r.intercepts(r2))
|
|
|
|
def testNoIntercept4(self):
|
|
r2 = evas.Rect(-10, -10, 30, 5)
|
|
self.assert_(not self.r.intercepts(r2))
|
|
|
|
def testNoIntercept5(self):
|
|
r2 = evas.Rect(-10, 15, 5, 5)
|
|
self.assert_(not self.r.intercepts(r2))
|
|
|
|
def testNoIntercept6(self):
|
|
r2 = evas.Rect(0, 15, 5, 5)
|
|
self.assert_(not self.r.intercepts(r2))
|
|
|
|
def testNoIntercept7(self):
|
|
r2 = evas.Rect(10, 15, 5, 5)
|
|
self.assert_(not self.r.intercepts(r2))
|
|
|
|
def testNoIntercept8(self):
|
|
r2 = evas.Rect(-10, 15, 30, 5)
|
|
self.assert_(not self.r.intercepts(r2))
|
|
|
|
def testNoIntercept9(self):
|
|
r2 = evas.Rect(-10, 5, 5, 5)
|
|
self.assert_(not self.r.intercepts(r2))
|
|
|
|
def testNoIntercept10(self):
|
|
r2 = evas.Rect(15, 5, 5, 5)
|
|
self.assert_(not self.r.intercepts(r2))
|
|
|
|
def testNoIntercept11(self):
|
|
r2 = evas.Rect(15, 15, 5, 5)
|
|
self.assert_(not self.r.intercepts(r2))
|
|
|
|
|
|
class TestRectClip(unittest.TestCase):
|
|
def setUp(self):
|
|
self.r = evas.Rect(0, 0, 10, 10)
|
|
|
|
def testClipContained(self):
|
|
r2 = evas.Rect(-10, -10, 30, 30)
|
|
self.assertEqual(self.r.clip(r2), self.r)
|
|
|
|
def testClipContains(self):
|
|
r2 = evas.Rect(5, 5, 2, 2)
|
|
self.assertEqual(self.r.clip(r2), r2)
|
|
|
|
def testClipOutside1(self):
|
|
r2 = evas.Rect(-10, -10, 5, 5)
|
|
self.assertEqual(self.r.clip(r2), evas.Rect(0, 0, 0, 0))
|
|
|
|
def testClipOutside2(self):
|
|
r2 = evas.Rect(15, 15, 5, 5)
|
|
self.assertEqual(self.r.clip(r2), evas.Rect(0, 0, 0, 0))
|
|
|
|
def testClipOutside3(self):
|
|
r2 = evas.Rect(-10, -10, 30, 5)
|
|
self.assertEqual(self.r.clip(r2), evas.Rect(0, 0, 0, 0))
|
|
|
|
def testInterceptTopLeft(self):
|
|
r2 = evas.Rect(-5, -5, 10, 10)
|
|
self.assertEqual(self.r.clip(r2), evas.Rect(0, 0, 5, 5))
|
|
|
|
def testInterceptTopRight(self):
|
|
r2 = evas.Rect(5, -5, 10, 10)
|
|
self.assertEqual(self.r.clip(r2), evas.Rect(5, 0, 5, 5))
|
|
|
|
def testInterceptBottomLeft(self):
|
|
r2 = evas.Rect(-5, 5, 10, 10)
|
|
self.assertEqual(self.r.clip(r2), evas.Rect(0, 5, 5, 5))
|
|
|
|
def testInterceptBottomRight(self):
|
|
r2 = evas.Rect(5, 5, 10, 10)
|
|
self.assertEqual(self.r.clip(r2), evas.Rect(5, 5, 5, 5))
|
|
|
|
def testInterceptLeft(self):
|
|
r2 = evas.Rect(-5, 2, 10, 5)
|
|
self.assertEqual(self.r.clip(r2), evas.Rect(0, 2, 5, 5))
|
|
|
|
def testInterceptRight(self):
|
|
r2 = evas.Rect(5, 2, 10, 5)
|
|
self.assertEqual(self.r.clip(r2), evas.Rect(5, 2, 5, 5))
|
|
|
|
def testInterceptTop(self):
|
|
r2 = evas.Rect(2, -5, 5, 10)
|
|
self.assertEqual(self.r.clip(r2), evas.Rect(2, 0, 5, 5))
|
|
|
|
def testInterceptBottom(self):
|
|
r2 = evas.Rect(2, 5, 5, 10)
|
|
self.assertEqual(self.r.clip(r2), evas.Rect(2, 5, 5, 5))
|
|
|
|
|
|
class TestRectUnion(unittest.TestCase):
|
|
def setUp(self):
|
|
self.r = evas.Rect(0, 0, 10, 10)
|
|
|
|
def testUnionContained(self):
|
|
r2 = evas.Rect(-10, -10, 30, 30)
|
|
self.assertEqual(self.r.union(r2), r2)
|
|
|
|
def testUnionContains(self):
|
|
r2 = evas.Rect(5, 5, 2, 2)
|
|
self.assertEqual(self.r.union(r2), self.r)
|
|
|
|
def testUnion(self):
|
|
r2 = evas.Rect(-10, -10, 5, 5)
|
|
self.assertEqual(self.r.union(r2), evas.Rect(-10, -10, 20, 20))
|
|
|
|
|
|
class TestRectClamp(unittest.TestCase):
|
|
def setUp(self):
|
|
self.r = evas.Rect(0, 0, 10, 10)
|
|
|
|
def testClampContained(self):
|
|
r2 = evas.Rect(-10, -10, 30, 30)
|
|
self.assertEqual(self.r.clamp(r2), self.r)
|
|
|
|
def testClampContains(self):
|
|
r2 = evas.Rect(0, 0, 4, 4)
|
|
# -3 = 4/2 - 5/2 (centered)
|
|
self.assertEqual(self.r.clamp(r2), evas.Rect(-3, -3, 10, 10))
|
|
|
|
def testClampTopLeft(self):
|
|
r2 = evas.Rect(5, 5, 20, 20)
|
|
self.assertEqual(self.r.clamp(r2), evas.Rect(5, 5, 10, 10))
|
|
|
|
def testClampTopRight(self):
|
|
r2 = evas.Rect(-15, 5, 20, 20)
|
|
self.assertEqual(self.r.clamp(r2), evas.Rect(-5, 5, 10, 10))
|
|
|
|
def testClampBottomLeft(self):
|
|
r2 = evas.Rect(5, -15, 20, 20)
|
|
self.assertEqual(self.r.clamp(r2), evas.Rect(5, -5, 10, 10))
|
|
|
|
def testClampBottomRight(self):
|
|
r2 = evas.Rect(-15, -15, 20, 20)
|
|
self.assertEqual(self.r.clamp(r2), evas.Rect(-5, -5, 10, 10))
|
|
|
|
|
|
if __name__ == '__main__':
|
|
unittest.main(verbosity=2)
|
|
evas.shutdown()
|