tests/pyatspi/componenttest.py

   1 import dbus
   2 import gobject
   3 import os.path
   4
   5 from xml.dom import minidom
   6 import os
   7
   8 from pasytest import PasyTest as _PasyTest
   9
  10 import pyatspi
  11 from pyatspi import Accessible
  12
  13 ATSPI_LAYER_WIDGET = 3
  14 ATSPI_LAYER_MDI = 4
  15 ATSPI_LAYER_WINDOW = 7
  16
  17 extents_expected = [(0,0,30,20), (40,30,30,40), (0,0,70,70)]
  18 sizes_expected = [(30,20), (30,40), (70,70)]
  19 positions_expected = [(0,0), (40,30), (0,0)]
  20 layers_expected = [ATSPI_LAYER_WINDOW, ATSPI_LAYER_WIDGET, ATSPI_LAYER_MDI]
  21 zorders_expected = [-100, 100]
  22
  23 class ComponentTest(_PasyTest):
  24
  25         __tests__ = ["setup",
  26                      "test_contains",
  27                      "test_getAccessibleAtPoint",
  28                      "test_getExtents",
  29                      "test_getPosition",
  30                      "test_getSize",
  31                      "test_getLayer",
  32                      "test_getMDIZOrder",
  33                      "test_grabFocus",
  34                      "test_registerFocusHandler",
  35                      "test_deregisterFocusHandler",
  36                      "test_getAlpha",
  37                      "teardown",
  38                      ]
  39
  40         def __init__(self, bus, path):
  41                 _PasyTest.__init__(self, "Accessible", False)
  42                 self._bus = bus
  43                 self._path = path
  44
  45         def setup(self, test):
  46                 self._cache = pyatspi.TestApplicationCache(self._bus, self._path)
  47
  48         def test_contains(self, test):
  49                 pass
  50
  51         def test_getAccessibleAtPoint(self, test):
  52                 pass
  53
  54         def test_getExtents(self, test):
  55                 root = self._cache.root
  56                 one = root.getChildAtIndex(0)
  57                 two = root.getChildAtIndex(1)
  58
  59                 comps = [one.queryComponent(),
  60                          two.queryComponent(),
  61                          root.queryComponent(),]
  62
  63                 for expected, comp in zip(extents_expected, comps):
  64                         extents = comp.getExtents(0)
  65                         test.assertEqual(extents, expected,
  66                                          "Extents not correct. Expected (%d, %d, %d, %d), Recieved (%d, %d, %d, %d)"
  67                                          % (expected[0], expected[1], expected[2], expected[3],
  68                                                 extents[0], extents[1], extents[2], extents[3]))
  69
  70         def test_getPosition(self, test):
  71                 pass
  72                 root = self._cache.root
  73                 one = root.getChildAtIndex(0)
  74                 two = root.getChildAtIndex(1)
  75
  76                 comps = [one.queryComponent(),
  77                          two.queryComponent(),
  78                          root.queryComponent(),]
  79
  80                 for expected, comp in zip(positions_expected, comps):
  81                         position = comp.getPosition(0)
  82                         test.assertEqual(position, expected,
  83                                          "Position not correct. Expected (%d, %d) Recieved (%d, %d)"
  84                                          % (expected[0], expected[1], position[0], position[1]))
  85
  86         def test_getSize(self, test):
  87                 root = self._cache.root
  88                 one = root.getChildAtIndex(0)
  89                 two = root.getChildAtIndex(1)
  90
  91                 comps = [one.queryComponent(),
  92                          two.queryComponent(),
  93                          root.queryComponent(),]
  94
  95                 for expected, comp in zip(sizes_expected, comps):
  96                         size = comp.getSize()
  97                         test.assertEqual(size, expected,
  98                                          "Size not correct. Expected (%d, %d) Recieved (%d, %d)"
  99                                          % (expected[0], expected[1], size[0], size[1]))
 100
 101         def test_getLayer(self, test):
 102                 root = self._cache.root
 103                 one = root.getChildAtIndex(0)
 104                 two = root.getChildAtIndex(1)
 105
 106                 comps = [one.queryComponent(),
 107                          two.queryComponent(),
 108                          root.queryComponent(),]
 109
 110                 for expected, comp in zip(layers_expected, comps):
 111                         layer = comp.getLayer()
 112                         test.assertEqual(layer, expected,
 113                                          "Layer not correct. Expected %d, Recieved %d"
 114                                          % (layer, expected))
 115
 116         def test_getMDIZOrder(self, test):
 117                 root = self._cache.root
 118                 one = root.getChildAtIndex(0)
 119                 two = root.getChildAtIndex(1)
 120
 121                 comps = [two.queryComponent(),
 122                          root.queryComponent(),]
 123
 124                 for expected, comp in zip(zorders_expected, comps):
 125                         mdizo = comp.getMDIZOrder()
 126                         test.assertEqual(mdizo, expected,
 127                                          "ZOrder not correct. Expected %d, Recieved %d"
 128                                          % (expected, mdizo))
 129
 130         def test_grabFocus(self, test):
 131                 pass
 132
 133         def test_registerFocusHandler(self, test):
 134                 pass
 135
 136         def test_deregisterFocusHandler(self, test):
 137                 pass
 138
 139         def test_getAlpha(self, test):
 140                 pass
 141
 142         def teardown(self, test):
 143                 pass