summaryrefslogtreecommitdiffstats
path: root/tests/QtGui
diff options
context:
space:
mode:
authorRenato Filho <renato.filho@openbossa.org>2010-06-07 14:43:45 -0300
committerRenato Filho <renato.filho@openbossa.org>2010-06-07 16:57:11 -0300
commitab918abc1e103e0ca86939f7d057e8a44ac8a4ef (patch)
tree53c6f57d089dcf5e145d766b1ceef704714046d8 /tests/QtGui
parent471486732b03cbb42b884158604a59d5a18e8a35 (diff)
downloadpyside-ab918abc1e103e0ca86939f7d057e8a44ac8a4ef.tar.gz
pyside-ab918abc1e103e0ca86939f7d057e8a44ac8a4ef.tar.xz
pyside-ab918abc1e103e0ca86939f7d057e8a44ac8a4ef.zip
Created new unittest model.
Separete unittest for module. Only run unittest for compiled modules. Reviewer: Marcelo Lira <marcelo.lira@openbossa.org>, Luciano Wolf <luciano.wolf@openbossa.org>
Diffstat (limited to 'tests/QtGui')
-rw-r--r--tests/QtGui/CMakeLists.txt58
-rw-r--r--tests/QtGui/add_action_test.py44
-rwxr-xr-xtests/QtGui/customproxywidget_test.py33
-rw-r--r--tests/QtGui/float_to_int_implicit_conversion_test.py32
-rw-r--r--tests/QtGui/grandparent_method_test.py23
-rw-r--r--tests/QtGui/hashabletype_test.py18
-rwxr-xr-xtests/QtGui/keep_reference_test.py75
-rw-r--r--tests/QtGui/missing_symbols_test.py29
-rw-r--r--tests/QtGui/paint_event_test.py71
-rw-r--r--tests/QtGui/parent_method_test.py25
-rw-r--r--tests/QtGui/python_properties_test.py15
-rw-r--r--tests/QtGui/qapp_test.py17
-rw-r--r--tests/QtGui/qapplication_exit_segfault_test.py17
-rw-r--r--tests/QtGui/qapplication_singleton_test.py12
-rw-r--r--tests/QtGui/qbrush_test.py24
-rw-r--r--tests/QtGui/qcolor_test.py68
-rw-r--r--tests/QtGui/qdatastream_gui_operators_test.py35
-rw-r--r--tests/QtGui/qfontdialog_test.py22
-rw-r--r--tests/QtGui/qfontmetrics_test.py189
-rwxr-xr-xtests/QtGui/qgraphicsitem_isblocked_test.py29
-rw-r--r--tests/QtGui/qgraphicsitem_test.py35
-rwxr-xr-xtests/QtGui/qgraphicsproxywidget_test.py29
-rw-r--r--tests/QtGui/qgraphicsscene_test.py152
-rw-r--r--tests/QtGui/qinputdialog_get_test.py27
-rw-r--r--tests/QtGui/qitemselection_test.py18
-rw-r--r--tests/QtGui/qlayout_ref_test.py112
-rw-r--r--tests/QtGui/qlayout_test.py52
-rw-r--r--tests/QtGui/qlcdnumber_test.py16
-rw-r--r--tests/QtGui/qlistwidgetitem_test.py25
-rw-r--r--tests/QtGui/qmainwindow_test.py32
-rw-r--r--tests/QtGui/qmatrix_test.py49
-rw-r--r--tests/QtGui/qmenu_test.py58
-rw-r--r--tests/QtGui/qmenuadd_test.py25
-rw-r--r--tests/QtGui/qobject_mi_test.py37
-rw-r--r--tests/QtGui/qpainter_test.py49
-rw-r--r--tests/QtGui/qpen_test.py20
-rw-r--r--tests/QtGui/qpixmap_test.py62
-rw-r--r--tests/QtGui/qpushbutton_test.py30
-rw-r--r--tests/QtGui/qradialgradient_test.py29
-rw-r--r--tests/QtGui/qregion_test.py21
-rw-r--r--tests/QtGui/qshortcut_test.py48
-rw-r--r--tests/QtGui/qstandarditemmodel_test.py26
-rw-r--r--tests/QtGui/qstring_qkeysequence_test.py40
-rwxr-xr-xtests/QtGui/qstyle_test.py32
-rw-r--r--tests/QtGui/qtableview_test.py17
-rw-r--r--tests/QtGui/qtabwidget_test.py21
-rw-r--r--tests/QtGui/qtextedit_test.py32
-rw-r--r--tests/QtGui/qtoolbar_test.py35
-rw-r--r--tests/QtGui/qtoolbox_test.py31
-rw-r--r--tests/QtGui/qvariant_test.py85
-rw-r--r--tests/QtGui/qwidget_setlayout_test.py33
-rw-r--r--tests/QtGui/qwidget_test.py30
-rw-r--r--tests/QtGui/reference_count_test.py71
-rw-r--r--tests/QtGui/sample.pngbin0 -> 55944 bytes
-rw-r--r--tests/QtGui/standardpixmap_test.py15
-rw-r--r--tests/QtGui/timed_app_test.py14
-rw-r--r--tests/QtGui/virtual_protected_inheritance_test.py70
-rw-r--r--tests/QtGui/virtual_pure_override.py48
-rw-r--r--tests/QtGui/wrong_return_test.py23
-rw-r--r--tests/QtGui/x11_symbols.py17
60 files changed, 2402 insertions, 0 deletions
diff --git a/tests/QtGui/CMakeLists.txt b/tests/QtGui/CMakeLists.txt
new file mode 100644
index 0000000..fb6d801
--- /dev/null
+++ b/tests/QtGui/CMakeLists.txt
@@ -0,0 +1,58 @@
+PYSIDE_TEST(add_action_test.py)
+PYSIDE_TEST(customproxywidget_test.py)
+PYSIDE_TEST(float_to_int_implicit_conversion_test.py)
+PYSIDE_TEST(grandparent_method_test.py)
+PYSIDE_TEST(hashabletype_test.py)
+PYSIDE_TEST(keep_reference_test.py)
+PYSIDE_TEST(missing_symbols_test.py)
+PYSIDE_TEST(paint_event_test.py)
+PYSIDE_TEST(parent_method_test.py)
+PYSIDE_TEST(python_properties_test.py)
+PYSIDE_TEST(qapplication_exit_segfault_test.py)
+PYSIDE_TEST(qapplication_singleton_test.py)
+PYSIDE_TEST(qapp_test.py)
+PYSIDE_TEST(qbrush_test.py)
+PYSIDE_TEST(qcolor_test.py)
+PYSIDE_TEST(qdatastream_gui_operators_test.py)
+PYSIDE_TEST(qfontdialog_test.py)
+PYSIDE_TEST(qfontmetrics_test.py)
+PYSIDE_TEST(qgraphicsitem_isblocked_test.py)
+PYSIDE_TEST(qgraphicsitem_test.py)
+PYSIDE_TEST(qgraphicsproxywidget_test.py)
+PYSIDE_TEST(qgraphicsscene_test.py)
+PYSIDE_TEST(qinputdialog_get_test.py)
+PYSIDE_TEST(qitemselection_test.py)
+PYSIDE_TEST(qlayout_ref_test.py)
+PYSIDE_TEST(qlayout_test.py)
+PYSIDE_TEST(qlcdnumber_test.py)
+PYSIDE_TEST(qlistwidgetitem_test.py)
+PYSIDE_TEST(qmainwindow_test.py)
+PYSIDE_TEST(qmatrix_test.py)
+PYSIDE_TEST(qmenuadd_test.py)
+PYSIDE_TEST(qmenu_test.py)
+PYSIDE_TEST(qobject_mi_test.py)
+PYSIDE_TEST(qpainter_test.py)
+PYSIDE_TEST(qpen_test.py)
+PYSIDE_TEST(qpixmap_test.py)
+PYSIDE_TEST(qpushbutton_test.py)
+PYSIDE_TEST(qradialgradient_test.py)
+PYSIDE_TEST(qregion_test.py)
+PYSIDE_TEST(qshortcut_test.py)
+PYSIDE_TEST(qstandarditemmodel_test.py)
+PYSIDE_TEST(qstring_qkeysequence_test.py)
+PYSIDE_TEST(qstyle_test.py)
+PYSIDE_TEST(qtableview_test.py)
+PYSIDE_TEST(qtabwidget_test.py)
+PYSIDE_TEST(qtextedit_test.py)
+PYSIDE_TEST(qtoolbar_test.py)
+PYSIDE_TEST(qtoolbox_test.py)
+PYSIDE_TEST(qvariant_test.py)
+PYSIDE_TEST(qwidget_setlayout_test.py)
+PYSIDE_TEST(qwidget_test.py TRUE) #Bug 237
+PYSIDE_TEST(reference_count_test.py)
+PYSIDE_TEST(standardpixmap_test.py)
+PYSIDE_TEST(timed_app_test.py)
+PYSIDE_TEST(virtual_protected_inheritance_test.py)
+PYSIDE_TEST(virtual_pure_override.py)
+PYSIDE_TEST(wrong_return_test.py)
+PYSIDE_TEST(x11_symbols.py)
diff --git a/tests/QtGui/add_action_test.py b/tests/QtGui/add_action_test.py
new file mode 100644
index 0000000..7e20c45
--- /dev/null
+++ b/tests/QtGui/add_action_test.py
@@ -0,0 +1,44 @@
+
+'''Tests for QMenuBar.addAction(identifier, callback) calls'''
+
+import unittest
+
+from PySide.QtCore import SLOT
+from PySide.QtGui import QMenuBar, QAction, QPushButton
+
+from helper import UsesQApplication
+
+
+class AddActionTest(UsesQApplication):
+ '''QMenuBar addAction'''
+
+ def tearDown(self):
+ try:
+ del self.called
+ except AttributeError:
+ pass
+ super(AddActionTest, self).tearDown()
+
+ def _callback(self):
+ self.called = True
+
+ def testBasic(self):
+ '''QMenuBar.addAction(id, callback)'''
+ menubar = QMenuBar()
+ action = menubar.addAction("Accounts", self._callback)
+ action.activate(QAction.Trigger)
+ self.assert_(self.called)
+
+ def testWithCppSlot(self):
+ '''QMenuBar.addAction(id, object, slot)'''
+ menubar = QMenuBar()
+ widget = QPushButton()
+ widget.setCheckable(True)
+ widget.setChecked(False)
+ action = menubar.addAction("Accounts", widget, SLOT("toggle()"))
+ action.activate(QAction.Trigger)
+ self.assert_(widget.isChecked())
+
+if __name__ == '__main__':
+ unittest.main()
+
diff --git a/tests/QtGui/customproxywidget_test.py b/tests/QtGui/customproxywidget_test.py
new file mode 100755
index 0000000..b9ccdff
--- /dev/null
+++ b/tests/QtGui/customproxywidget_test.py
@@ -0,0 +1,33 @@
+import unittest
+
+from helper import UsesQApplication
+from PySide.QtCore import Qt, QTimer
+from PySide.QtGui import QLabel, QPainter
+from PySide.QtGui import QGraphicsScene, QGraphicsView, QGraphicsItem, QGraphicsProxyWidget
+
+class CustomProxy(QGraphicsProxyWidget):
+ def __init__(self, parent=None, wFlags=0):
+ QGraphicsProxyWidget.__init__(self, parent, wFlags)
+
+class CustomProxyWidgetTest(UsesQApplication):
+ def testCustomProxyWidget(self):
+ scene = QGraphicsScene()
+
+ proxy = CustomProxy(None, Qt.Window)
+ widget = QLabel('Widget')
+ proxy.setWidget(widget)
+ proxy.setCacheMode(QGraphicsItem.DeviceCoordinateCache)
+ scene.addItem(proxy)
+ scene.setSceneRect(scene.itemsBoundingRect())
+
+ view = QGraphicsView(scene)
+ view.setRenderHints(QPainter.Antialiasing|QPainter.SmoothPixmapTransform)
+ view.setViewportUpdateMode(QGraphicsView.BoundingRectViewportUpdate)
+ view.show()
+
+ timer = QTimer.singleShot(100, self.app.quit)
+ self.app.exec_()
+
+if __name__ == '__main__':
+ unittest.main()
+
diff --git a/tests/QtGui/float_to_int_implicit_conversion_test.py b/tests/QtGui/float_to_int_implicit_conversion_test.py
new file mode 100644
index 0000000..cc7d18f
--- /dev/null
+++ b/tests/QtGui/float_to_int_implicit_conversion_test.py
@@ -0,0 +1,32 @@
+
+'''Test cases for QImage'''
+
+import unittest
+
+from PySide.QtGui import QImage, qRgb
+
+from helper import UsesQApplication
+
+class SetPixelFloat(UsesQApplication):
+ '''Test case for calling setPixel with float as argument'''
+
+ def setUp(self):
+ #Acquire resources
+ super(SetPixelFloat, self).setUp()
+ self.color = qRgb(255, 0, 0)
+ self.image = QImage(200, 200, QImage.Format_RGB32)
+
+ def tearDown(self):
+ #Release resources
+ del self.color
+ del self.image
+ super(SetPixelFloat, self).tearDown()
+
+ def testFloat(self):
+ #QImage.setPixel(float, float, color) - Implicit conversion
+ self.image.setPixel(3.14, 4.2, self.color)
+ self.assertEqual(self.image.pixel(3.14, 4.2), self.color)
+
+
+if __name__ == '__main__':
+ unittest.main()
diff --git a/tests/QtGui/grandparent_method_test.py b/tests/QtGui/grandparent_method_test.py
new file mode 100644
index 0000000..3c18293
--- /dev/null
+++ b/tests/QtGui/grandparent_method_test.py
@@ -0,0 +1,23 @@
+
+'''Tests for calling methods further than the direct parent'''
+
+import unittest
+
+from PySide.QtGui import QPushButton, QWidget
+
+from helper import UsesQApplication
+
+class Dummy(QPushButton):
+
+ def show(self):
+ QWidget.show(self)
+ self.called = True
+
+class GrandParentMethod(UsesQApplication):
+ def testMethod(self):
+ obj = Dummy()
+ obj.show()
+ self.assert_(obj.called)
+
+if __name__ == '__main__':
+ unittest.main()
diff --git a/tests/QtGui/hashabletype_test.py b/tests/QtGui/hashabletype_test.py
new file mode 100644
index 0000000..64683a3
--- /dev/null
+++ b/tests/QtGui/hashabletype_test.py
@@ -0,0 +1,18 @@
+'''Test cases for __hash__'''
+
+import unittest
+
+from PySide.QtGui import QTreeWidgetItem
+from helper import UsesQApplication
+
+class HashableTest(UsesQApplication):
+
+ def testQTreeWidgetItemHash(self):
+ h = {}
+ obj = QTreeWidgetItem()
+ h[obj] = 2
+ self.assert_(h.get(obj), 2)
+
+if __name__ == '__main__':
+ unittest.main()
+
diff --git a/tests/QtGui/keep_reference_test.py b/tests/QtGui/keep_reference_test.py
new file mode 100755
index 0000000..d0962d5
--- /dev/null
+++ b/tests/QtGui/keep_reference_test.py
@@ -0,0 +1,75 @@
+#!/usr/bin/env python
+
+import unittest
+
+from sys import getrefcount
+from helper import UsesQApplication
+from PySide.QtCore import QAbstractTableModel, QVariant
+from PySide.QtGui import QTableView
+
+class TestModel(QAbstractTableModel):
+ def __init__(self, parent=None):
+ QAbstractTableModel.__init__(self, parent)
+ def rowCount(self, parent):
+ return 0
+ def columnCount(self, parent):
+ return 0
+ def data(self, index, role):
+ return QVariant()
+
+class KeepReferenceTest(UsesQApplication):
+
+ def testModelWithoutParent(self):
+ view = QTableView()
+ model = TestModel()
+ view.setModel(model)
+ samemodel = view.model()
+ self.assertEqual(model, samemodel)
+
+ def testModelWithParent(self):
+ view = QTableView()
+ model = TestModel(self.app)
+ view.setModel(model)
+ samemodel = view.model()
+ self.assertEqual(model, samemodel)
+
+ def testReferenceCounting(self):
+ '''Tests reference count of model object referred by view objects.'''
+ model1 = TestModel()
+ refcount1 = getrefcount(model1)
+ view1 = QTableView()
+ view1.setModel(model1)
+ self.assertEqual(getrefcount(view1.model()), refcount1 + 1)
+
+ view2 = QTableView()
+ view2.setModel(model1)
+ self.assertEqual(getrefcount(view2.model()), refcount1 + 2)
+
+ model2 = TestModel()
+ view2.setModel(model2)
+ self.assertEqual(getrefcount(view1.model()), refcount1 + 1)
+
+ def testReferenceCountingWhenDeletingReferrer(self):
+ '''Tests reference count of model object referred by deceased view object.'''
+ model = TestModel()
+ refcount1 = getrefcount(model)
+ view = QTableView()
+ view.setModel(model)
+ self.assertEqual(getrefcount(view.model()), refcount1 + 1)
+
+ del view
+ self.assertEqual(getrefcount(model), refcount1)
+
+ def testReferreedObjectSurvivalAfterContextEnd(self):
+ '''Model object assigned to a view object must survive after getting out of context.'''
+ def createModelAndSetToView(view):
+ model = TestModel()
+ model.setObjectName('created model')
+ view.setModel(model)
+ view = QTableView()
+ createModelAndSetToView(view)
+ model = view.model()
+
+if __name__ == '__main__':
+ unittest.main()
+
diff --git a/tests/QtGui/missing_symbols_test.py b/tests/QtGui/missing_symbols_test.py
new file mode 100644
index 0000000..de23c56
--- /dev/null
+++ b/tests/QtGui/missing_symbols_test.py
@@ -0,0 +1,29 @@
+
+'''(Very) Simple test case for missing names from QtGui'''
+
+import unittest
+from PySide import QtGui
+
+class MissingClasses(unittest.TestCase):
+ def testQDrag(self): # Bug 222
+ getattr(QtGui, 'QDrag')
+
+ def testQDropEvent(self): # Bug 255
+ getattr(QtGui, 'QDropEvent')
+
+class MissingMembers(unittest.TestCase):
+
+ def testQFontMetricsSize(self): # Bug 223
+ QtGui.QFontMetrics.size
+
+ def testQLayoutSetSpacing(self): # Bug 231
+ QtGui.QLayout.setSpacing
+
+ def testQImageLoad(self): # Bug 257
+ QtGui.QImage.load
+
+ def testQStandardItemModelinsertRow(self): # Bug 227
+ QtGui.QStandardItemModel.insertRow
+
+if __name__ == '__main__':
+ unittest.main()
diff --git a/tests/QtGui/paint_event_test.py b/tests/QtGui/paint_event_test.py
new file mode 100644
index 0000000..0225390
--- /dev/null
+++ b/tests/QtGui/paint_event_test.py
@@ -0,0 +1,71 @@
+
+'''Test paint event override in python'''
+
+import unittest
+
+from PySide.QtCore import QTimerEvent
+from PySide.QtGui import QApplication, QWidget
+
+from helper import UsesQApplication
+
+class MyWidget(QWidget):
+ '''Sample widget'''
+
+ def __init__(self, app=None):
+ #Creates a new widget
+ if app is None:
+ app = QApplication([])
+
+ super(MyWidget, self).__init__()
+ self.app = app
+ self.runs = 0
+ self.max_runs = 5
+ self.paint_event_called = False
+
+ def timerEvent(self, event):
+ #Timer event method
+ self.runs += 1
+
+ if self.runs == self.max_runs:
+ self.app.quit()
+
+ if not isinstance(event, QTimerEvent):
+ raise TypeError('Invalid event type. Must be QTimerEvent')
+
+ def paintEvent(self, event):
+ #Empty paint event method
+ # XXX: should be using super here, but somehow PyQt4
+ # complains about paintEvent not present in super
+ QWidget.paintEvent(self, event)
+ self.paint_event_called = True
+
+
+class PaintEventOverride(UsesQApplication):
+ '''Test case for overriding QWidget.paintEvent'''
+
+ qapplication = True
+
+ def setUp(self):
+ #Acquire resources
+ super(PaintEventOverride, self).setUp()
+ self.widget = MyWidget(self.app)
+
+ def tearDown(self):
+ #Release resources
+ del self.widget
+ super(PaintEventOverride, self).tearDown()
+
+ def testPaintEvent(self):
+ #Test QWidget.paintEvent override
+ timer_id = self.widget.startTimer(100)
+ self.widget.show()
+ self.app.exec_()
+
+ self.widget.killTimer(timer_id)
+
+ self.assert_(self.widget.paint_event_called)
+ self.assertEqual(self.widget.runs, 5)
+
+
+if __name__ == '__main__':
+ unittest.main()
diff --git a/tests/QtGui/parent_method_test.py b/tests/QtGui/parent_method_test.py
new file mode 100644
index 0000000..8d0ba96
--- /dev/null
+++ b/tests/QtGui/parent_method_test.py
@@ -0,0 +1,25 @@
+
+import unittest
+
+from PySide.QtCore import QObject, QTimer, QThread
+from PySide.QtGui import *
+
+class Foo(QTableView):
+ def __init__(self, parent=None):
+ QTableView.__init__(self, parent)
+
+from helper import UsesQApplication
+
+class TestParentType(UsesQApplication):
+
+ def testParentType(self):
+ # Test the problem with calling QObject.parent from a QWidget
+ # when the parent is a python class derived from a QWidget-derived
+ # class. The method was returning the last C++ class in the hierarchy
+ parent = Foo()
+ w2 = QWidget(parent)
+ self.assert_(isinstance(w2.parentWidget(), Foo))
+ self.assert_(isinstance(w2.parent(), Foo))
+
+if __name__ == '__main__':
+ unittest.main()
diff --git a/tests/QtGui/python_properties_test.py b/tests/QtGui/python_properties_test.py
new file mode 100644
index 0000000..7d6c024
--- /dev/null
+++ b/tests/QtGui/python_properties_test.py
@@ -0,0 +1,15 @@
+import unittest
+from PySide import QtGui, QtCore
+
+class Properties(unittest.TestCase):
+
+ def testStaticProperty(self):
+ self.assertEqual(QtGui.QGraphicsItem.UserType, 65536)
+
+ def testInstanceProperty(self):
+ p = QtGui.QStyleOptionViewItemV3()
+ self.assert_(isinstance(p.locale, QtCore.QLocale))
+
+
+if __name__ == '__main__':
+ unittest.main()
diff --git a/tests/QtGui/qapp_test.py b/tests/QtGui/qapp_test.py
new file mode 100644
index 0000000..c371492
--- /dev/null
+++ b/tests/QtGui/qapp_test.py
@@ -0,0 +1,17 @@
+
+''' Test the presence of qApp Macro'''
+
+import unittest
+
+from PySide import QtGui
+
+class QAppPresence(unittest.TestCase):
+
+ def testQApp(self):
+ #QtGui.qApp variable is instance of QApplication
+ self.assert_(isinstance(QtGui.qApp, QtGui.QApplication))
+
+
+if __name__ == '__main__':
+ app = QtGui.QApplication([])
+ unittest.main()
diff --git a/tests/QtGui/qapplication_exit_segfault_test.py b/tests/QtGui/qapplication_exit_segfault_test.py
new file mode 100644
index 0000000..72b810a
--- /dev/null
+++ b/tests/QtGui/qapplication_exit_segfault_test.py
@@ -0,0 +1,17 @@
+
+import unittest
+import sys
+
+from PySide.QtGui import QApplication, QPushButton, QWidget, QSpinBox
+
+class QApplicationDelete(unittest.TestCase):
+ '''Test for segfault when deleting a QApplication before a QWidget'''
+
+ def testQPushButton(self):
+ #QApplication deleted before QPushButton
+ a = QApplication([])
+ b = QPushButton('aaaa')
+ del a
+
+if __name__ == '__main__':
+ unittest.main()
diff --git a/tests/QtGui/qapplication_singleton_test.py b/tests/QtGui/qapplication_singleton_test.py
new file mode 100644
index 0000000..9c959f9
--- /dev/null
+++ b/tests/QtGui/qapplication_singleton_test.py
@@ -0,0 +1,12 @@
+
+import unittest
+
+from PySide.QtGui import QApplication
+
+class TestSingleton(unittest.TestCase):
+ def testBasic(self):
+ a = QApplication([])
+ self.assertRaises(RuntimeError, QApplication, [])
+
+if __name__ == '__main__':
+ unittest.main()
diff --git a/tests/QtGui/qbrush_test.py b/tests/QtGui/qbrush_test.py
new file mode 100644
index 0000000..cf11652
--- /dev/null
+++ b/tests/QtGui/qbrush_test.py
@@ -0,0 +1,24 @@
+
+'''Test cases for QBrush'''
+
+import unittest
+
+from PySide.QtCore import Qt
+from PySide.QtGui import QApplication, QColor, QBrush
+
+from helper import UsesQApplication
+
+class Constructor(UsesQApplication):
+ '''Test case for constructor of QBrush'''
+
+ def testQColor(self):
+ #QBrush(QColor) constructor
+ color = QColor('black')
+ obj = QBrush(color)
+ self.assertEqual(obj.color(), color)
+
+ obj = QBrush(Qt.blue)
+ self.assertEqual(obj.color(), Qt.blue)
+
+if __name__ == '__main__':
+ unittest.main()
diff --git a/tests/QtGui/qcolor_test.py b/tests/QtGui/qcolor_test.py
new file mode 100644
index 0000000..3c2f11b
--- /dev/null
+++ b/tests/QtGui/qcolor_test.py
@@ -0,0 +1,68 @@
+
+import unittest
+import colorsys
+
+from PySide.QtCore import Qt
+from PySide.QtGui import QColor
+
+
+class QColorGetTest(unittest.TestCase):
+
+ def setUp(self):
+ self.color = QColor(20, 40, 60, 80)
+
+ def testGetRgb(self):
+ self.assertEqual(self.color.getRgb(), (20, 40, 60, 80))
+
+ def testGetRgbF(self):
+ self.assertEqual(self.color.getRgbF(), (20.0/255, 40.0/255, 60.0/255, 80.0/255))
+
+ def testGetHsl(self):
+ self.assertEqual(self.color.getHsl(), (210, 128, 40, self.color.alpha()))
+
+ def testGetHslF(self):
+ hls = colorsys.rgb_to_hls(20.0/255, 40.0/255, 60.0/255)
+ hsla = hls[0], hls[2], hls[1], self.color.alphaF()
+ for x, y in zip(self.color.getHslF(), hsla): # Due to rounding problems
+ self.assert_(x - y < 1/100000.0)
+
+ def testGetHsv(self):
+ hsv = colorsys.rgb_to_hsv(20.0/255, 40.0/255, 60.0/255)
+ hsva = int(hsv[0]*360.0), int(hsv[1]*255), int(hsv[2]*256), self.color.alpha()
+ self.assertEqual(self.color.getHsv(), hsva)
+
+ def testGetHsvF(self):
+ hsv = colorsys.rgb_to_hsv(20.0/255, 40.0/255, 60.0/255)
+ hsva = hsv[0], hsv[1], hsv[2], self.color.alphaF()
+ self.assertEqual(self.color.getHsvF(), hsva)
+
+ def testGetCmyk(self): # not supported by colorsys
+ self.assertEqual(self.color.getCmyk(), (170, 85, 0, 195, 80))
+
+ def testGetCmykF(self): # not supported by colorsys
+ for x, y in zip(self.color.getCmykF(), (170/255.0, 85/255.0, 0, 195/255.0, 80/255.0)):
+ self.assert_(x - y < 1/10000.0)
+
+
+class QColorQRgbConstructor(unittest.TestCase):
+ '''QColor(QRgb) constructor'''
+ # Affected by bug #170 - QColor(QVariant) coming before QColor(uint)
+ # in overload sorting
+
+ def testBasic(self):
+ '''QColor(QRgb)'''
+ color = QColor(255, 0, 0)
+ #QRgb format #AARRGGBB
+ rgb = 0x00FF0000
+ self.assertEqual(QColor(rgb), color)
+
+
+class QColorEqualGlobalColor(unittest.TestCase):
+
+ def testEqualGlobalColor(self):
+ '''QColor == Qt::GlobalColor'''
+ self.assertEqual(QColor(255, 0, 0), Qt.red)
+
+
+if __name__ == '__main__':
+ unittest.main()
diff --git a/tests/QtGui/qdatastream_gui_operators_test.py b/tests/QtGui/qdatastream_gui_operators_test.py
new file mode 100644
index 0000000..dbb638f
--- /dev/null
+++ b/tests/QtGui/qdatastream_gui_operators_test.py
@@ -0,0 +1,35 @@
+# -*- coding: utf-8 -*-
+
+import unittest
+import sys
+
+from PySide.QtCore import QDataStream, QByteArray, QIODevice, Qt
+from PySide.QtGui import QPixmap, QColor
+
+from helper import UsesQApplication
+
+class QPixmapQDatastream(UsesQApplication):
+ '''QDataStream <<>> QPixmap'''
+
+ def setUp(self):
+ super(QPixmapQDatastream, self).setUp()
+ self.source_pixmap = QPixmap(100, 100)
+ self.source_pixmap.fill(Qt.red)
+ self.output_pixmap = QPixmap()
+ self.buffer = QByteArray()
+ self.read_stream = QDataStream(self.buffer, QIODevice.ReadOnly)
+ self.write_stream = QDataStream(self.buffer, QIODevice.WriteOnly)
+
+ def testStream(self):
+ self.write_stream << self.source_pixmap
+
+ self.read_stream >> self.output_pixmap
+
+ image = self.output_pixmap.toImage()
+ pixel = image.pixel(10,10)
+ self.assertEqual(pixel, QColor(Qt.red).rgba())
+ self.assertEqual(self.source_pixmap.toImage(), self.output_pixmap.toImage())
+
+
+if __name__ == '__main__':
+ unittest.main()
diff --git a/tests/QtGui/qfontdialog_test.py b/tests/QtGui/qfontdialog_test.py
new file mode 100644
index 0000000..02bce78
--- /dev/null
+++ b/tests/QtGui/qfontdialog_test.py
@@ -0,0 +1,22 @@
+import unittest
+import sys
+
+from PySide import QtGui
+from PySide import QtCore
+
+from helper import TimedQApplication
+
+class TestFontDialog(TimedQApplication):
+
+ def testGetFont(self):
+ QtGui.QFontDialog.getFont()
+
+ def testGetFontQDialog(self):
+ QtGui.QFontDialog.getFont(QtGui.QFont("FreeSans",10))
+
+ def testGetFontQDialogQString(self):
+ QtGui.QFontDialog.getFont(QtGui.QFont("FreeSans",10), None, "Select font")
+
+if __name__ == '__main__':
+ unittest.main()
+
diff --git a/tests/QtGui/qfontmetrics_test.py b/tests/QtGui/qfontmetrics_test.py
new file mode 100644
index 0000000..7964d91
--- /dev/null
+++ b/tests/QtGui/qfontmetrics_test.py
@@ -0,0 +1,189 @@
+
+'''Tests for inject codes and modifications on QFontMetrics
+ and QFontMetricsF'''
+
+import unittest
+from PySide.QtGui import QFont, QFontMetrics, QFontMetricsF
+from PySide.QtCore import QRect, QRectF, Qt, QSize, QSizeF
+from helper import UsesQApplication
+
+
+class QFontMetricsTest(UsesQApplication):
+ '''Base class for QFontMetrics tests'''
+
+ def setUp(self):
+ super(QFontMetricsTest, self).setUp()
+ self.font = QFont()
+ self.metrics = QFontMetrics(self.font)
+
+ def tearDown(self):
+ del self.metrics
+ del self.font
+ super(QFontMetricsTest, self).tearDown()
+
+
+class BoundingRectTest(QFontMetricsTest):
+ '''Tests for QFontMetrics.boundingRect inject code'''
+
+ def testIntDefault(self):
+ '''QFontMetrics.boundingRect(int, int, int, int, ...) - default args'''
+ rect = self.metrics.boundingRect(0, 0, 0, 0,
+ Qt.TextExpandTabs | Qt.AlignLeft,
+ 'PySide by INdT')
+ self.assert_(isinstance(rect, QRect))
+
+ def testIntWithArg(self):
+ '''QFontMetrics.boundingRect(int, int, int, int, ...) - single arg'''
+ rect = self.metrics.boundingRect(0, 0, 0, 0,
+ Qt.TextExpandTabs | Qt.AlignLeft,
+ 'PySide by INdT', 2)
+ self.assert_(isinstance(rect, QRect))
+
+ def testIntWithFull(self):
+ '''QFontMetrics.boundingRect(int, int, int, int, ...) - all argss'''
+ rect = self.metrics.boundingRect(0, 0, 0, 0,
+ Qt.TextExpandTabs | Qt.AlignLeft,
+ 'PySide by INdT', 20, [1, 2, 3, 4, 5])
+ self.assert_(isinstance(rect, QRect))
+
+ def testIntTypeError(self):
+ '''QFontMetrics.boundingRect(int, int, int, int, ...) - type error'''
+ self.assertRaises(TypeError, self.metrics.boundingRect, 0, 0, 0, 0,
+ Qt.TextExpandTabs | Qt.AlignLeft,
+ 'PySide by INdT', 20, ['aaaa', 'ase'])
+
+ def testQRectDefault(self):
+ '''QFontMetrics.boundingRect(QRect, ...) - default args'''
+ arg = QRect(0, 0, 100, 200)
+ rect = self.metrics.boundingRect(arg, Qt.TextExpandTabs | Qt.AlignLeft,
+ 'PySide by INdT')
+ self.assert_(isinstance(rect, QRect))
+
+ def testQRectWithArg(self):
+ '''QFontMetrics.boundingRect(QRect, ...) - only tabstops'''
+ arg = QRect(0, 0, 100, 200)
+ rect = self.metrics.boundingRect(arg, Qt.TextExpandTabs | Qt.AlignLeft,
+ 'PySide by INdT', 2)
+ self.assert_(isinstance(rect, QRect))
+
+ def testQRectWithFull(self):
+ '''QFontMetrics.boundingRect(QRect, ...) - all arguments'''
+ arg = QRect(0, 0, 100, 200)
+ rect = self.metrics.boundingRect(arg, Qt.TextExpandTabs | Qt.AlignLeft,
+ 'PySide by INdT', 20,
+ [1, 2, 3, 4, 5])
+ self.assert_(isinstance(rect, QRect))
+
+ def testQRectTypeError(self):
+ '''QFontMetrics.boundingRect(QRect, ...) - type error'''
+ arg = QRect(0, 0, 100, 200)
+ self.assertRaises(TypeError, self.metrics.boundingRect, arg,
+ Qt.TextExpandTabs | Qt.AlignLeft,
+ 'PySide by INdT', 20, ['aaaa', 'ase'])
+
+
+class SizeTest(QFontMetricsTest):
+ '''Tests for QFontMetrics.size inject code'''
+
+ def testDefault(self):
+ '''QFontMetrics.size - default arguments'''
+ size = self.metrics.size(Qt.TextExpandTabs | Qt.TextSingleLine,
+ 'PySide by INdT')
+ self.assert_(isinstance(size, QSize))
+
+ def testWithTabStops(self):
+ '''QFontMetrics.size - only tabstops'''
+ size = self.metrics.size(Qt.TextExpandTabs | Qt.TextSingleLine,
+ 'PySide by INdT', 2)
+ self.assert_(isinstance(size, QSize))
+
+ def testFull(self):
+ '''QFontMetrics.size - all arguments'''
+ size = self.metrics.size(Qt.TextExpandTabs | Qt.TextSingleLine,
+ 'PySide by INdT', 2, [1, 2, 3, 4])
+ self.assert_(isinstance(size, QSize))
+
+ def testTypeError(self):
+ '''QFontMetrics.size - type error'''
+ self.assertRaises(TypeError, self.metrics.size,
+ Qt.TextExpandTabs | Qt.AlignLeft,
+ 'PySide by INdT', 20, ['aaaa', 'ase'])
+
+
+class QFontMetricsFTest(UsesQApplication):
+ '''Base class for QFontMetrics tests'''
+
+ def setUp(self):
+ super(QFontMetricsFTest, self).setUp()
+ self.font = QFont()
+ self.metrics = QFontMetricsF(self.font)
+
+ def tearDown(self):
+ del self.metrics
+ del self.font
+ super(QFontMetricsFTest, self).tearDown()
+
+
+class FBoundingRectTest(QFontMetricsFTest):
+ '''Tests for QFontMetricsF.boundingRect inject code'''
+
+ def testQRectDefault(self):
+ '''QFontMetricsF.boundingRect(QRectF, ...) - default args'''
+ arg = QRectF(0, 0, 100, 200)
+ rect = self.metrics.boundingRect(arg, Qt.TextExpandTabs | Qt.AlignLeft,
+ 'PySide by INdT')
+ self.assert_(isinstance(rect, QRectF))
+
+ def testQRectWithArg(self):
+ '''QFontMetricsF.boundingRect(QRectF, ...) - only tabstops'''
+ arg = QRectF(0, 0, 100, 200)
+ rect = self.metrics.boundingRect(arg, Qt.TextExpandTabs | Qt.AlignLeft,
+ 'PySide by INdT', 2)
+ self.assert_(isinstance(rect, QRectF))
+
+ def testQRectWithFull(self):
+ '''QFontMetricsF.boundingRect(QRectF, ...) - all arguments'''
+ arg = QRectF(0, 0, 100, 200)
+ rect = self.metrics.boundingRect(arg, Qt.TextExpandTabs | Qt.AlignLeft,
+ 'PySide by INdT', 20,
+ [1, 2, 3, 4, 5])
+ self.assert_(isinstance(rect, QRectF))
+
+ def testQRectTypeError(self):
+ '''QFontMetricsF.boundingRect(QRectF, ...) - type error'''
+ arg = QRectF(0, 0, 100, 200)
+ self.assertRaises(TypeError, self.metrics.boundingRect, arg,
+ Qt.TextExpandTabs | Qt.AlignLeft,
+ 'PySide by INdT', 20, ['aaaa', 'ase'])
+
+
+class FSizeTest(QFontMetricsFTest):
+ '''Tests for QFontMetricsF.size inject code'''
+
+ def testDefault(self):
+ '''QFontMetricsF.size - default arguments'''
+ size = self.metrics.size(Qt.TextExpandTabs | Qt.TextSingleLine,
+ 'PySide by INdT')
+ self.assert_(isinstance(size, QSizeF))
+
+ def testWithTabStops(self):
+ '''QFontMetricsF.size - only tabstops'''
+ size = self.metrics.size(Qt.TextExpandTabs | Qt.TextSingleLine,
+ 'PySide by INdT', 2)
+ self.assert_(isinstance(size, QSizeF))
+
+ def testFull(self):
+ '''QFontMetricsF.size - all arguments'''
+ size = self.metrics.size(Qt.TextExpandTabs | Qt.TextSingleLine,
+ 'PySide by INdT', 2, [1, 2, 3, 4])
+ self.assert_(isinstance(size, QSizeF))
+
+ def testTypeError(self):
+ '''QFontMetricsF.size - type error'''
+ self.assertRaises(TypeError, self.metrics.size,
+ Qt.TextExpandTabs | Qt.AlignLeft,
+ 'PySide by INdT', 20, ['aaaa', 'ase'])
+
+
+if __name__ == '__main__':
+ unittest.main()
diff --git a/tests/QtGui/qgraphicsitem_isblocked_test.py b/tests/QtGui/qgraphicsitem_isblocked_test.py
new file mode 100755
index 0000000..b281c8a
--- /dev/null
+++ b/tests/QtGui/qgraphicsitem_isblocked_test.py
@@ -0,0 +1,29 @@
+#!/usr/bin/python
+
+import unittest
+
+from PySide import QtCore
+from PySide import QtGui
+from helper import UsesQApplication
+
+class Item(QtGui.QGraphicsItem):
+
+ def __init__(self):
+ QtGui.QGraphicsItem.__init__(self)
+
+ def boundingRect(self):
+ return QtCore.QRectF(0, 0, 100, 100)
+
+ def paint(self, painter, option, widget):
+ painter.setBrush(QtGui.QColor(255, 255, 255))
+ painter.drawRect(0, 0, 100, 100)
+
+
+class QGraphicsViewIsBlockedTest(UsesQApplication):
+
+ def testIsBlockedByModalPanel(self):
+ (first, second) = Item().isBlockedByModalPanel()
+ self.assertFalse(first)
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/tests/QtGui/qgraphicsitem_test.py b/tests/QtGui/qgraphicsitem_test.py
new file mode 100644
index 0000000..43545a4
--- /dev/null
+++ b/tests/QtGui/qgraphicsitem_test.py
@@ -0,0 +1,35 @@
+
+''' Test cases related to QGraphicsItem and subclasses'''
+
+import unittest
+
+from PySide.QtGui import QGraphicsScene, QPolygonF, QColor, QBrush
+
+from helper import UsesQApplication
+
+class QColorOnSetBrush(UsesQApplication):
+ '''Test case for passing a QColor directly to setBrush'''
+
+ def setUp(self):
+ #Acquire resources
+ super(QColorOnSetBrush, self).setUp()
+
+ self.scene = QGraphicsScene()
+ poly = QPolygonF()
+ self.item = self.scene.addPolygon(poly)
+ self.color = QColor('black')
+
+ def tearDown(self):
+ #Release resources
+ del self.color
+ del self.item
+ del self.scene
+ super(QColorOnSetBrush, self).tearDown()
+
+ def testQColor(self):
+ #QGraphicsAbstractShapeItem.setBrush(QColor)
+ self.item.setBrush(self.color)
+ self.assertEqual(QBrush(self.color), self.item.brush())
+
+if __name__ == '__main__':
+ unittest.main()
diff --git a/tests/QtGui/qgraphicsproxywidget_test.py b/tests/QtGui/qgraphicsproxywidget_test.py
new file mode 100755
index 0000000..3a856bc
--- /dev/null
+++ b/tests/QtGui/qgraphicsproxywidget_test.py
@@ -0,0 +1,29 @@
+import unittest
+
+from helper import UsesQApplication
+from PySide.QtCore import Qt, QTimer
+from PySide.QtGui import QLabel, QPainter
+from PySide.QtGui import QGraphicsScene, QGraphicsView, QGraphicsItem, QGraphicsProxyWidget
+
+class QGraphicsProxyWidgetTest(UsesQApplication):
+ def testQGraphicsProxyWidget(self):
+ scene = QGraphicsScene()
+
+ proxy = QGraphicsProxyWidget(None, Qt.Window)
+ widget = QLabel('Widget')
+ proxy.setWidget(widget)
+ proxy.setCacheMode(QGraphicsItem.DeviceCoordinateCache)
+ scene.addItem(proxy)
+ scene.setSceneRect(scene.itemsBoundingRect())
+
+ view = QGraphicsView(scene)
+ view.setRenderHints(QPainter.Antialiasing|QPainter.SmoothPixmapTransform)
+ view.setViewportUpdateMode(QGraphicsView.BoundingRectViewportUpdate)
+ view.show()
+
+ timer = QTimer.singleShot(100, self.app.quit)
+ self.app.exec_()
+
+if __name__ == '__main__':
+ unittest.main()
+
diff --git a/tests/QtGui/qgraphicsscene_test.py b/tests/QtGui/qgraphicsscene_test.py
new file mode 100644
index 0000000..98177e7
--- /dev/null
+++ b/tests/QtGui/qgraphicsscene_test.py
@@ -0,0 +1,152 @@
+
+'''Basic test cases for QGraphicsScene'''
+
+import unittest
+import gc
+
+from PySide.QtCore import QPointF
+from PySide.QtGui import QApplication, QPushButton, QPolygonF, QPixmap
+from PySide.QtGui import QGraphicsScene, QPainterPath
+from PySide.QtGui import QGraphicsEllipseItem, QGraphicsLineItem
+from PySide.QtGui import QGraphicsPathItem, QGraphicsPixmapItem
+from PySide.QtGui import QGraphicsPolygonItem, QGraphicsRectItem
+from PySide.QtGui import QGraphicsSimpleTextItem, QGraphicsTextItem
+from PySide.QtGui import QGraphicsProxyWidget
+
+from helper import UsesQApplication
+
+class Constructor(unittest.TestCase):
+ '''QGraphicsScene constructor'''
+
+ def testConstructor(self):
+ #QGraphicsScene constructor
+ obj = QGraphicsScene()
+ self.assert_(isinstance(obj, QGraphicsScene))
+
+
+class ConstructorWithRect(unittest.TestCase):
+ '''QGraphicsScene qrect constructor and related sizes'''
+
+ def setUp(self):
+ #Acquire resources
+ # PyQt4 doesn't accept a QRect as argument to constructor
+ self.scene = QGraphicsScene(0, 200, 150, 175)
+
+ def tearDown(self):
+ #Release resources
+ del self.scene
+
+ def testHeight(self):
+ #QGraphicsScene.height()
+ self.assertEqual(self.scene.height(), 175)
+
+ def testWidth(self):
+ #QGraphicsScene.width()
+ self.assertEqual(self.scene.width(), 150)
+
+
+class AddItem(UsesQApplication):
+ '''Tests for QGraphicsScene.add*'''
+
+ qapplication = True
+
+ def setUp(self):
+ #Acquire resources
+ super(AddItem, self).setUp()
+ self.scene = QGraphicsScene()
+ # While the scene does not inherits from QWidget, requires
+ # an application to make the internals work.
+
+ def tearDown(self):
+ #Release resources
+ del self.scene
+ super(AddItem, self).tearDown()
+
+ def testEllipse(self):
+ #QGraphicsScene.addEllipse
+ item = self.scene.addEllipse(100, 100, 100, 100)
+ self.assert_(isinstance(item, QGraphicsEllipseItem))
+
+ def testLine(self):
+ #QGraphicsScene.addLine
+ item = self.scene.addLine(100, 100, 200, 200)
+ self.assert_(isinstance(item, QGraphicsLineItem))
+
+ def testPath(self):
+ #QGraphicsScene.addPath
+ item = self.scene.addPath(QPainterPath())
+ self.assert_(isinstance(item, QGraphicsPathItem))
+
+ def testPixmap(self):
+ #QGraphicsScene.addPixmap
+ item = self.scene.addPixmap(QPixmap())
+ self.assert_(isinstance(item, QGraphicsPixmapItem))
+
+ def testPolygon(self):
+ #QGraphicsScene.addPolygon
+ points = [QPointF(0, 0), QPointF(100, 100), QPointF(0, 100)]
+ item = self.scene.addPolygon(QPolygonF(points))
+ self.assert_(isinstance(item, QGraphicsPolygonItem))
+
+ def testRect(self):
+ #QGraphicsScene.addRect
+ item = self.scene.addRect(100, 100, 100, 100)
+ self.assert_(isinstance(item, QGraphicsRectItem))
+
+ def testSimpleText(self):
+ #QGraphicsScene.addSimpleText
+ item = self.scene.addSimpleText('Monty Python 42')
+ self.assert_(isinstance(item, QGraphicsSimpleTextItem))
+
+ def testText(self):
+ #QGraphicsScene.addText
+ item = self.scene.addText('Monty Python 42')
+ self.assert_(isinstance(item, QGraphicsTextItem))
+
+ def testWidget(self):
+ #QGraphicsScene.addWidget
+ # XXX: printing some X11 error when using under PyQt4
+ item = self.scene.addWidget(QPushButton())
+ self.assert_(isinstance(item, QGraphicsProxyWidget))
+
+
+class ItemRetrieve(UsesQApplication):
+ '''Tests for QGraphicsScene item retrieval methods'''
+
+ qapplication = True
+
+ def setUp(self):
+ #Acquire resources
+ super(ItemRetrieve, self).setUp()
+ self.scene = QGraphicsScene()
+
+ self.topleft = QGraphicsRectItem(0, 0, 100, 100)
+ self.topright = QGraphicsRectItem(100, 0, 100, 100)
+ self.bottomleft = QGraphicsRectItem(0, 100, 100, 100)
+ self.bottomright = QGraphicsRectItem(100, 100, 100, 100)
+
+ self.items = [self.topleft, self.topright, self.bottomleft,
+ self.bottomright]
+
+ for item in self.items:
+ self.scene.addItem(item)
+
+ def tearDown(self):
+ #Release resources
+ del self.scene
+ super(ItemRetrieve, self).tearDown()
+
+ def testItems(self):
+ #QGraphicsScene.items()
+ items = self.scene.items()
+ self.assertEqual(items.sort(), self.items.sort())
+
+ def testItemAt(self):
+ #QGraphicsScene.itemAt()
+ self.assertEqual(self.scene.itemAt(50, 50), self.topleft)
+ self.assertEqual(self.scene.itemAt(150, 50), self.topright)
+ self.assertEqual(self.scene.itemAt(50, 150), self.bottomleft)
+ self.assertEqual(self.scene.itemAt(150, 150), self.bottomright)
+
+if __name__ == '__main__':
+ unittest.main()
diff --git a/tests/QtGui/qinputdialog_get_test.py b/tests/QtGui/qinputdialog_get_test.py
new file mode 100644
index 0000000..c75f712
--- /dev/null
+++ b/tests/QtGui/qinputdialog_get_test.py
@@ -0,0 +1,27 @@
+import unittest
+
+from PySide import QtCore, QtGui
+from helper import UsesQApplication, TimedQApplication
+
+class TestInputDialog(TimedQApplication):
+
+ def testGetDouble(self):
+ self.assertEquals(QtGui.QInputDialog.getDouble(None, "title", "label"), (0.0, False))
+
+ def testGetInt(self):
+ self.assertEquals(QtGui.QInputDialog.getInt(None, "title", "label"), (0, False))
+
+ def testGetInteger(self):
+ self.assertEquals(QtGui.QInputDialog.getInteger(None, "title", "label"), (0, False))
+
+ def testGetItem(self):
+ (item, bool) = QtGui.QInputDialog.getItem(None, "title", "label", QtCore.QStringList(["1", "2", "3"]))
+ self.assertEquals(str(item), "1")
+
+ def testGetText(self):
+ (text, bool) = QtGui.QInputDialog.getText(None, "title", "label")
+ self.assertEquals(str(text),"")
+
+if __name__ == '__main__':
+ unittest.main()
+
diff --git a/tests/QtGui/qitemselection_test.py b/tests/QtGui/qitemselection_test.py
new file mode 100644
index 0000000..8c6c34e
--- /dev/null
+++ b/tests/QtGui/qitemselection_test.py
@@ -0,0 +1,18 @@
+import unittest
+
+from helper import UsesQApplication
+from PySide.QtGui import QItemSelection, QStandardItemModel
+
+class QItemSelectionTest(UsesQApplication):
+ def testLen(self):
+ model = QStandardItemModel(2, 2)
+ model.insertRow(0)
+ model.insertRow(1)
+ model.insertColumn(0)
+ model.insertColumn(1)
+ selection = QItemSelection(model.index(0,0), model.index(1,1))
+ self.assertEqual(len(selection), 1)
+
+if __name__ == '__main__':
+ unittest.main()
+
diff --git a/tests/QtGui/qlayout_ref_test.py b/tests/QtGui/qlayout_ref_test.py
new file mode 100644
index 0000000..a634271
--- /dev/null
+++ b/tests/QtGui/qlayout_ref_test.py
@@ -0,0 +1,112 @@
+
+'''Test cases for QLayout handling of child widgets references'''
+
+import unittest
+from sys import getrefcount
+
+from PySide.QtGui import QHBoxLayout, QVBoxLayout, QGridLayout, QWidget
+from PySide.QtGui import QStackedLayout, QFormLayout
+from PySide.QtGui import QApplication, QPushButton, QLabel
+
+from helper import UsesQApplication
+
+class SaveReference(UsesQApplication):
+ '''Test case to check if QLayout-derived classes increment the refcount
+ of widgets passed to addWidget()'''
+
+ # Adding here as nose can't see the qapplication attrib we inherit
+ qapplication = True
+
+ def setUp(self):
+ #Acquire resources
+ super(SaveReference, self).setUp()
+ self.widget1 = QPushButton('click me')
+ self.widget2 = QLabel('aaa')
+
+ def tearDown(self):
+ #Release resources
+ del self.widget2
+ del self.widget1
+ super(SaveReference, self).tearDown()
+
+ def checkLayoutReference(self, layout):
+ #Checks the reference cound handling of layout.addWidget
+ self.assertEqual(getrefcount(self.widget1), 2)
+ layout.addWidget(self.widget1)
+ self.assertEqual(getrefcount(self.widget1), 3)
+
+ self.assertEqual(getrefcount(self.widget2), 2)
+ layout.addWidget(self.widget2)
+ self.assertEqual(getrefcount(self.widget2), 3)
+
+ # Check if doesn't mess around with previous widget refcount
+ self.assertEqual(getrefcount(self.widget1), 3)
+
+ def testMoveLayout(self):
+ l = QHBoxLayout()
+ self.assertEqual(getrefcount(self.widget1), 2)
+ l.addWidget(self.widget1)
+ self.assertEqual(getrefcount(self.widget1), 2)
+
+ w = QWidget()
+ w.setLayout(l)
+ self.assertEqual(getrefcount(self.widget1), 3)
+
+
+ def testHBoxReference(self):
+ #QHBoxLayout.addWidget reference count
+ w = QWidget()
+ self.checkLayoutReference(QHBoxLayout(w))
+
+ def testVBoxReference(self):
+ #QVBoxLayout.addWidget reference count
+ w = QWidget()
+ self.checkLayoutReference(QVBoxLayout(w))
+
+ def testGridReference(self):
+ #QGridLayout.addWidget reference count
+ w = QWidget()
+ self.checkLayoutReference(QGridLayout(w))
+
+ def testFormReference(self):
+ #QFormLayout.addWidget reference count
+ w = QWidget()
+ self.checkLayoutReference(QFormLayout(w))
+
+ def testStackedReference(self):
+ #QStackedLayout.addWidget reference count
+ w = QWidget()
+ self.checkLayoutReference(QStackedLayout(w))
+
+class MultipleAdd(UsesQApplication):
+ '''Test case to check if refcount is incremented only once when multiple
+ calls to addWidget are made with the same widget'''
+
+ qapplication = True
+
+ def setUp(self):
+ #Acquire resources
+ super(MultipleAdd, self).setUp()
+ self.widget = QPushButton('click me')
+ self.win = QWidget()
+ self.layout = QHBoxLayout(self.win)
+
+ def tearDown(self):
+ #Release resources
+ del self.widget
+ del self.layout
+ del self.win
+ super(MultipleAdd, self).tearDown()
+
+ def testRefCount(self):
+ #Multiple QLayout.addWidget calls on the same widget
+ self.assertEqual(getrefcount(self.widget), 2)
+ self.layout.addWidget(self.widget)
+ self.assertEqual(getrefcount(self.widget), 3)
+ self.layout.addWidget(self.widget)
+ self.assertEqual(getrefcount(self.widget), 3)
+ self.layout.addWidget(self.widget)
+ self.assertEqual(getrefcount(self.widget), 3)
+
+if __name__ == '__main__':
+ unittest.main()
diff --git a/tests/QtGui/qlayout_test.py b/tests/QtGui/qlayout_test.py
new file mode 100644
index 0000000..ae773bb
--- /dev/null
+++ b/tests/QtGui/qlayout_test.py
@@ -0,0 +1,52 @@
+import unittest
+import sys
+
+from helper import UsesQApplication
+from PySide.QtGui import QLayout, QWidget, QPushButton, QWidgetItem
+
+class MyLayout(QLayout):
+ def __init__(self, parent=None):
+ QLayout.__init__(self, parent)
+ self._list = []
+
+ def addItem(self, item):
+ self.add(item)
+
+ def addWidget(self, widget):
+ self.add(QWidgetItem(widget))
+
+ def itemAt(self, index):
+ if index < len(self._list):
+ return self._list[index]
+
+ return None
+
+ def count(self):
+ return len(self._list)
+
+ def add(self, item):
+ self._list.append(item)
+
+
+
+#Test if a layout implemented in python, the QWidget.setLayout works
+#fine because this implement som layout functions used in glue code of
+#QWidget, then in c++ when call a virtual function this need call the QLayout
+#function implemented in python
+
+class QLayoutTest(UsesQApplication):
+
+ def testOwnershipTransfer(self):
+ b = QPushButton("teste")
+ l = MyLayout()
+ l.addWidget(b)
+
+ self.assertEqual(sys.getrefcount(b), 2)
+
+ w = QWidget()
+ w.setLayout(l)
+
+ self.assertEqual(sys.getrefcount(b), 3)
+
+if __name__ == '__main__':
+ unittest.main()
diff --git a/tests/QtGui/qlcdnumber_test.py b/tests/QtGui/qlcdnumber_test.py
new file mode 100644
index 0000000..eb6a4f3
--- /dev/null
+++ b/tests/QtGui/qlcdnumber_test.py
@@ -0,0 +1,16 @@
+import unittest
+
+from PySide.QtGui import QApplication, QLCDNumber
+
+class QLCDNumberOverflow(unittest.TestCase):
+ '''Test case for unhandled overflow on QLCDNumber() numDigits argument (see bug #215).'''
+
+ def setUp(self):
+ self.app = QApplication([])
+
+ def testnumDigitsOverflow(self):
+ # NOTE: PyQt4 raises TypeError, but boost.python raises OverflowError
+ self.assertRaises(OverflowError, QLCDNumber, 840835495615213080)
+
+if __name__ == '__main__':
+ unittest.main()
diff --git a/tests/QtGui/qlistwidgetitem_test.py b/tests/QtGui/qlistwidgetitem_test.py
new file mode 100644
index 0000000..8f96c51
--- /dev/null
+++ b/tests/QtGui/qlistwidgetitem_test.py
@@ -0,0 +1,25 @@
+
+import unittest
+
+from PySide import QtGui
+
+from helper import UsesQApplication
+
+class QListWidgetItemConstructor(UsesQApplication):
+
+ def setUp(self):
+ super(QListWidgetItemConstructor, self).setUp()
+ self.widgetList = QtGui.QListWidget()
+
+ def tearDown(self):
+ del self.widgetList
+ super(QListWidgetItemConstructor, self).tearDown()
+
+ def testConstructorWithParent(self):
+ # Bug 235 - QListWidgetItem constructor not saving ownership
+ QtGui.QListWidgetItem(self.widgetList)
+ item = self.widgetList.item(0)
+ self.assertEqual(item.listWidget(), self.widgetList)
+
+if __name__ == '__main__':
+ unittest.main()
diff --git a/tests/QtGui/qmainwindow_test.py b/tests/QtGui/qmainwindow_test.py
new file mode 100644
index 0000000..fce145d
--- /dev/null
+++ b/tests/QtGui/qmainwindow_test.py
@@ -0,0 +1,32 @@
+import unittest
+import sys
+
+from PySide import QtGui
+from PySide import QtCore
+
+from helper import UsesQApplication
+
+class MainWindow(QtGui.QMainWindow):
+ def __init__(self):
+ QtGui.QMainWindow.__init__(self)
+
+ self.createToolbar()
+
+ def createToolbar(self):
+ pointerButton = QtGui.QToolButton()
+ pointerToolbar = self.addToolBar("Pointer type")
+ pointerToolbar.addWidget(pointerButton)
+
+
+class TestMainWindow(UsesQApplication):
+
+ def testCreateToolbar(self):
+ w = MainWindow()
+ w.show()
+ QtCore.QTimer.singleShot(1000, self.app.quit)
+ self.app.exec_()
+
+
+if __name__ == '__main__':
+ unittest.main()
+
diff --git a/tests/QtGui/qmatrix_test.py b/tests/QtGui/qmatrix_test.py
new file mode 100644
index 0000000..7c87e23
--- /dev/null
+++ b/tests/QtGui/qmatrix_test.py
@@ -0,0 +1,49 @@
+import unittest
+
+from PySide.QtCore import QPoint
+from PySide.QtGui import QMatrix, QMatrix4x4
+
+
+def qpointTimesQMatrix(point, matrix):
+ '''As seen in "QPoint QMatrix::map(const QPoint &p) const" C++ implementation.'''
+ return QPoint(matrix.m11() * point.x() + matrix.m21() * point.y() + matrix.dx(),
+ matrix.m12() * point.x() + matrix.m22() * point.y() + matrix.dy())
+
+class QMatrixTest(unittest.TestCase):
+
+ def testMatrix(self):
+ matrix = QMatrix(11, 12, 21, 22, 100, 200)
+ point = QPoint(3, 3)
+ self.assertEqual(point * matrix, qpointTimesQMatrix(point, matrix))
+
+ def testMatrixWithWrongType(self):
+ matrix = QMatrix(11, 12, 21, 22, 100, 200)
+ point = QPoint(3, 3)
+ self.assertRaises(TypeError, matrix.__mul__, point)
+
+ def testMatrix4x4(self):
+ self.assertRaises(TypeError, QMatrix4x4, [0.0, 1.0, 2.0, 3.0])
+ self.assertRaises(TypeError, QMatrix4x4, [0.0, 1.0, 2.0, 'I',
+ 4.0, 5.0, 6.0, 7.0,
+ 8.0, 9.0, 'N', 11.0,
+ 12.0, 'd', 14.0, 'T'])
+
+ my_data = [0.0, 1.0, 2.0, 3.0,
+ 4.0, 5.0, 6.0, 7.0,
+ 8.0, 9.0, 10.0, 11.0,
+ 12.0, 13.0, 14.0, 15.0]
+ my_datac = [0.0, 4.0, 8.0, 12.0,
+ 1.0, 5.0, 9.0, 13.0,
+ 2.0, 6.0, 10.0, 14.0,
+ 3.0, 7.0, 11.0, 15.0]
+
+ m = QMatrix4x4(my_data)
+ d = m.data()
+ self.assert_(my_datac, d)
+
+ d = m.copyDataTo()
+ self.assert_(my_data == list(d))
+
+if __name__ == '__main__':
+ unittest.main()
+
diff --git a/tests/QtGui/qmenu_test.py b/tests/QtGui/qmenu_test.py
new file mode 100644
index 0000000..37faf16
--- /dev/null
+++ b/tests/QtGui/qmenu_test.py
@@ -0,0 +1,58 @@
+
+import unittest
+
+from PySide.QtGui import QMenu, QKeySequence, QIcon
+from PySide.QtCore import SLOT
+
+from helper import UsesQApplication
+
+class QMenuAddAction(UsesQApplication):
+
+ def setUp(self):
+ super(QMenuAddAction, self).setUp()
+ self.menu = QMenu()
+
+ def tearDown(self):
+ del self.menu
+ super(QMenuAddAction, self).tearDown()
+
+ def testAddActionWithoutKeySequenceCallable(self):
+ # bug #280
+ action = self.menu.addAction(self.app.tr('aaa'), lambda : 1)
+
+ def testAddActionKeySequenceCallable(self):
+ # bug #228
+ action = self.menu.addAction(self.app.tr('aaa'), lambda : 1,
+ QKeySequence(self.app.tr('Ctrl+O')))
+
+ def testAddActionKeySequenceSlot(self):
+ action = self.menu.addAction('Quit', self.app, SLOT('quit()'),
+ QKeySequence('Ctrl+O'))
+
+class QMenuAddActionWithIcon(UsesQApplication):
+
+ def setUp(self):
+ super(QMenuAddActionWithIcon, self).setUp()
+ self.menu = QMenu()
+ self.icon = QIcon()
+
+ def tearDown(self):
+ del self.menu
+ del self.icon
+ super(QMenuAddActionWithIcon, self).tearDown()
+
+ def testAddActionWithoutKeySequenceCallable(self):
+ # bug #280
+ action = self.menu.addAction(self.icon, self.app.tr('aaa'), lambda : 1)
+
+ def testAddActionKeySequenceCallable(self):
+ # bug #228
+ action = self.menu.addAction(self.icon, self.app.tr('aaa'), lambda : 1,
+ QKeySequence(self.app.tr('Ctrl+O')))
+
+ def testAddActionKeySequenceSlot(self):
+ action = self.menu.addAction(self.icon, 'Quit', self.app, SLOT('quit()'),
+ QKeySequence('Ctrl+O'))
+
+if __name__ == '__main__':
+ unittest.main()
diff --git a/tests/QtGui/qmenuadd_test.py b/tests/QtGui/qmenuadd_test.py
new file mode 100644
index 0000000..47b112b
--- /dev/null
+++ b/tests/QtGui/qmenuadd_test.py
@@ -0,0 +1,25 @@
+# -*- coding: utf-8 -*-
+
+''' Test the QMenu.addAction() method'''
+
+import unittest
+import sys
+
+from PySide import QtGui
+
+from helper import UsesQApplication
+
+class QMenuAddAction(UsesQApplication):
+
+ def openFile(self, *args):
+ self.arg = args
+
+ def testQMenuAddAction(self):
+ fileMenu = QtGui.QMenu("&File")
+
+ addNewAction = fileMenu.addAction("&Open...", self.openFile)
+ addNewAction.trigger()
+ self.assertEquals(self.arg, ())
+
+if __name__ == '__main__':
+ unittest.main()
diff --git a/tests/QtGui/qobject_mi_test.py b/tests/QtGui/qobject_mi_test.py
new file mode 100644
index 0000000..8ccc1d3
--- /dev/null
+++ b/tests/QtGui/qobject_mi_test.py
@@ -0,0 +1,37 @@
+'''Test cases for multiple inheritance from 2 QObjects'''
+
+import unittest
+
+from PySide.QtCore import QObject
+from PySide.QtGui import *
+
+from helper import UsesQApplication
+
+class WidgetValidator(QWidget, QIntValidator):
+ def __init__(self, parent=None):
+ QWidget.__init__(self, parent)
+ QIntValidator.__init__(self, parent)
+
+
+class DoubleQObjectInheritanceTest(UsesQApplication):
+
+ def testDouble(self):
+ '''Double inheritance from QObject classes'''
+
+ obj = WidgetValidator()
+
+ #QObject methods
+ obj.setObjectName('aaaa')
+ self.assertEqual(obj.objectName(), 'aaaa')
+
+ #QWidget methods
+ obj.setVisible(False)
+ self.assertFalse(obj.isVisible())
+
+ #QIntValidator methods
+ self.assertEqual(obj.validate('aaaa', 0), QValidator.Invalid)
+ self.assertEqual(obj.validate('33', 0), QValidator.Acceptable)
+
+
+if __name__ == '__main__':
+ unittest.main()
diff --git a/tests/QtGui/qpainter_test.py b/tests/QtGui/qpainter_test.py
new file mode 100644
index 0000000..ad1d1e4
--- /dev/null
+++ b/tests/QtGui/qpainter_test.py
@@ -0,0 +1,49 @@
+import unittest
+
+from PySide.QtGui import QPainter, QBrush, QLinearGradient
+from PySide.QtCore import QRect, QRectF, Qt
+
+class QPainterDrawText(unittest.TestCase):
+
+ def setUp(self):
+ self.painter = QPainter()
+ self.text = 'teste!'
+
+ def tearDown(self):
+ del self.text
+ del self.painter
+
+ def testDrawText(self):
+ # bug #254
+ rect = self.painter.drawText(100, 100, 100, 100,
+ Qt.AlignCenter | Qt.TextWordWrap,
+ self.text)
+ self.assert_(isinstance(rect, QRect))
+
+ def testDrawTextWithRect(self):
+ # bug #225
+ rect = QRect(100, 100, 100, 100)
+ newRect = self.painter.drawText(rect, Qt.AlignCenter | Qt.TextWordWrap,
+ self.text)
+
+ self.assert_(isinstance(newRect, QRect))
+
+ def testDrawTextWithRectF(self):
+ '''QPainter.drawText(QRectF, ... ,QRectF*) inject code'''
+ rect = QRectF(100, 52.3, 100, 100)
+ newRect = self.painter.drawText(rect, Qt.AlignCenter | Qt.TextWordWrap,
+ self.text)
+
+ self.assert_(isinstance(newRect, QRectF))
+
+class SetBrushWithOtherArgs(unittest.TestCase):
+ '''Using qpainter.setBrush with args other than QBrush'''
+
+ def testSetBrushGradient(self):
+ painter = QPainter()
+ gradient = QLinearGradient(0, 0, 0, 0)
+ painter.setBrush(gradient)
+
+if __name__ == '__main__':
+ unittest.main()
+
diff --git a/tests/QtGui/qpen_test.py b/tests/QtGui/qpen_test.py
new file mode 100644
index 0000000..f9e9b18
--- /dev/null
+++ b/tests/QtGui/qpen_test.py
@@ -0,0 +1,20 @@
+
+import unittest
+
+from PySide.QtCore import Qt
+from PySide.QtGui import QPen
+
+class QPenTest(unittest.TestCase):
+
+ def testCtorWithCreatedEnums(self):
+ '''A simple case of QPen creation using created enums.'''
+ width = 0
+ style = Qt.PenStyle(0)
+ cap = Qt.PenCapStyle(0)
+ join = Qt.PenJoinStyle(0)
+ pen = QPen(Qt.blue, width, style, cap, join)
+
+
+if __name__ == '__main__':
+ unittest.main()
+
diff --git a/tests/QtGui/qpixmap_test.py b/tests/QtGui/qpixmap_test.py
new file mode 100644
index 0000000..4814094
--- /dev/null
+++ b/tests/QtGui/qpixmap_test.py
@@ -0,0 +1,62 @@
+import unittest
+
+import os
+from helper import UsesQApplication
+from PySide.QtGui import *
+from PySide.QtCore import *
+
+class QPixmapTest(UsesQApplication):
+ def testQVariantConstructor(self):
+ pixmap = QPixmap()
+ v = QVariant(pixmap)
+ pixmap_copy = QPixmap(v)
+
+ def testQSizeConstructor(self):
+ pixmap = QPixmap(QSize(10,20))
+ self.assert_(pixmap.size().height(), 20)
+
+ def testQStringConstructor(self):
+ pixmap = QPixmap(QString("Testing!"))
+
+ def testQVariantConstructor2(self):
+ v = QVariant(QPixmap())
+ pixmap2 = QPixmap(v)
+ v = QVariant(QImage())
+ pixmap2 = QPixmap(v)
+
+ def testQPixmapLoadFromDataWithQFile(self):
+ f = QFile(os.path.join(os.path.dirname(__file__), 'sample.png'))
+ self.assert_(f.open(QIODevice.ReadOnly))
+ data = f.read(f.size())
+ f.close()
+ pixmap = QPixmap()
+ self.assert_(pixmap.loadFromData(data))
+
+ def testQPixmapLoadFromDataWithPython(self):
+ data = open(os.path.join(os.path.dirname(__file__),'sample.png'),'rb').read()
+ pixmap = QPixmap()
+ self.assert_(pixmap.loadFromData(data))
+
+
+class QPixmapToImage(UsesQApplication):
+
+ def testFilledImage(self):
+ '''QPixmap.fill + toImage + image.pixel'''
+ pixmap = QPixmap(100, 200)
+ pixmap.fill(Qt.red) # Default Qt.white
+
+ self.assertEqual(pixmap.height(), 200)
+ self.assertEqual(pixmap.width(), 100)
+
+ image = pixmap.toImage()
+
+ self.assertEqual(image.height(), 200)
+ self.assertEqual(image.width(), 100)
+
+ pixel = image.pixel(10,10)
+ self.assertEqual(pixel, QColor(Qt.red).rgba())
+
+
+if __name__ == '__main__':
+ unittest.main()
+
diff --git a/tests/QtGui/qpushbutton_test.py b/tests/QtGui/qpushbutton_test.py
new file mode 100644
index 0000000..9849608
--- /dev/null
+++ b/tests/QtGui/qpushbutton_test.py
@@ -0,0 +1,30 @@
+import unittest
+
+from helper import UsesQApplication
+from PySide.QtGui import QPushButton, QMenu, QWidget
+from PySide.QtCore import QTimer
+
+class MyWidget(QWidget):
+ def __init__(self):
+ QWidget.__init__(self)
+
+ m = QMenu(self)
+ b = QPushButton("Hello", self)
+ b.setMenu(m)
+
+
+class QPushButtonTest(UsesQApplication):
+ def createMenu(self, button):
+ m = QMenu()
+ button.setMenu(m)
+
+ def testSetMenu(self):
+ w = MyWidget()
+ w.show()
+
+ timer = QTimer.singleShot(100, self.app.quit)
+ self.app.exec_()
+
+if __name__ == '__main__':
+ unittest.main()
+
diff --git a/tests/QtGui/qradialgradient_test.py b/tests/QtGui/qradialgradient_test.py
new file mode 100644
index 0000000..0c582c3
--- /dev/null
+++ b/tests/QtGui/qradialgradient_test.py
@@ -0,0 +1,29 @@
+import unittest
+
+from PySide.QtGui import QRadialGradient
+from PySide.QtCore import QPointF
+
+class QRadialGradientConstructor(unittest.TestCase):
+ def _compare(self, qptf, tpl):
+ self.assertEqual((qptf.x(), qptf.y()), tpl)
+
+ def _assertValues(self, grad):
+ self._compare(grad.center(), (1.0, 2.0))
+ self._compare(grad.focalPoint(), (3.0, 4.0))
+ self.assertEqual(grad.radius(), 5.0)
+
+ def testAllInt(self):
+ grad = QRadialGradient(1, 2, 5, 3, 4)
+ self._assertValues(grad)
+
+ def testQPointF(self):
+ grad = QRadialGradient(QPointF(1, 2), 5, QPointF(3, 4))
+ self._assertValues(grad)
+
+ def testSetQPointF(self):
+ grad = QRadialGradient()
+ grad.setCenter(QPointF(1, 2))
+ self._compare(grad.center(), (1.0, 2.0))
+
+if __name__ == '__main__':
+ unittest.main()
diff --git a/tests/QtGui/qregion_test.py b/tests/QtGui/qregion_test.py
new file mode 100644
index 0000000..2274d5e
--- /dev/null
+++ b/tests/QtGui/qregion_test.py
@@ -0,0 +1,21 @@
+import unittest
+import sys
+
+from PySide.QtGui import QRegion
+from PySide.QtCore import QPoint
+from helper import UsesQApplication
+
+class QRegionTest(UsesQApplication):
+
+ def testFunctionUnit(self):
+ r = QRegion(0, 0, 10, 10)
+ r2 = QRegion(5, 5, 10, 10)
+
+ ru = r.united(r2)
+ self.assert_(ru.contains(QPoint(0,0)))
+ self.assert_(ru.contains(QPoint(5,5)))
+ self.assert_(ru.contains(QPoint(10,10)))
+ self.assert_(ru.contains(QPoint(14,14)))
+
+if __name__ == '__main__':
+ unittest.main()
diff --git a/tests/QtGui/qshortcut_test.py b/tests/QtGui/qshortcut_test.py
new file mode 100644
index 0000000..c9cb3bc
--- /dev/null
+++ b/tests/QtGui/qshortcut_test.py
@@ -0,0 +1,48 @@
+# -*- coding: utf-8 -*-
+
+''' Test the QShortcut constructor'''
+
+import unittest
+import sys
+
+from PySide import QtGui, QtCore
+
+class Foo(QtGui.QWidget):
+ def __init__(self):
+ QtGui.QWidget.__init__(self)
+ self.ok = False
+ self.copy = False
+
+ def slot_of_foo(self):
+ self.ok = True
+
+ def slot_of_copy(self):
+ self.copy = True
+
+class MyShortcut(QtGui.QShortcut):
+ def __init__(self, keys, wdg, slot):
+ QtGui.QShortcut.__init__(self, keys, wdg, slot)
+
+ def emit_signal(self):
+ self.emit(QtCore.SIGNAL("activated()"))
+
+class QAppPresence(unittest.TestCase):
+
+ def testQShortcut(self):
+ self.qapp = QtGui.QApplication([])
+ f = Foo()
+
+ self.sc = MyShortcut(QtGui.QKeySequence(QtCore.Qt.Key_Return), f, f.slot_of_foo)
+ self.scstd = MyShortcut(QtGui.QKeySequence.Copy, f, f.slot_of_copy)
+ QtCore.QTimer.singleShot(0, self.init);
+ self.qapp.exec_()
+ self.assertEquals(f.ok, True)
+ self.assertEquals(f.copy, True)
+
+ def init(self):
+ self.sc.emit_signal();
+ self.scstd.emit_signal();
+ self.qapp.quit()
+
+if __name__ == '__main__':
+ unittest.main()
diff --git a/tests/QtGui/qstandarditemmodel_test.py b/tests/QtGui/qstandarditemmodel_test.py
new file mode 100644
index 0000000..d83d856
--- /dev/null
+++ b/tests/QtGui/qstandarditemmodel_test.py
@@ -0,0 +1,26 @@
+import unittest
+
+from PySide.QtGui import *
+from PySide.QtCore import *
+
+from helper import UsesQApplication
+
+class QStandardItemModelTest(UsesQApplication):
+
+ def setUp(self):
+ super(QStandardItemModelTest, self).setUp()
+ self.window = QWidget()
+ self.model = QStandardItemModel(0, 3, self.window)
+
+ def tearDown(self):
+ del self.window
+ del self.model
+ super(QStandardItemModelTest, self).tearDown()
+
+ def testInsertRow(self):
+ # bug #227
+ self.model.insertRow(0)
+
+if __name__ == '__main__':
+ unittest.main()
+
diff --git a/tests/QtGui/qstring_qkeysequence_test.py b/tests/QtGui/qstring_qkeysequence_test.py
new file mode 100644
index 0000000..1f435e6
--- /dev/null
+++ b/tests/QtGui/qstring_qkeysequence_test.py
@@ -0,0 +1,40 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+'''Tests conversions of QString to and from QKeySequence.'''
+
+import unittest
+from helper import UsesQApplication
+
+from PySide.QtCore import QString
+from PySide.QtGui import QKeySequence, QAction
+
+class QStringQKeySequenceTest(UsesQApplication):
+ '''Tests conversions of QString to and from QKeySequence.'''
+
+ def testQStringFromQKeySequence(self):
+ '''Creates a QString from a QKeySequence.'''
+ keyseq = 'Ctrl+A'
+ a = QString(QKeySequence(keyseq))
+ self.assertEqual(a, keyseq)
+
+ def testQStringAsQKeySequence(self):
+ '''Passes a QString to an argument expecting a QKeySequence.'''
+ keyseq = QString('Ctrl+A')
+ action = QAction(None)
+ action.setShortcut(keyseq)
+ shortcut = action.shortcut()
+ self.assert_(isinstance(shortcut, QKeySequence))
+ self.assertEqual(shortcut.toString(), keyseq)
+
+ def testPythonStringAsQKeySequence(self):
+ '''Passes a Python string to an argument expecting a QKeySequence.'''
+ keyseq = 'Ctrl+A'
+ action = QAction(None)
+ action.setShortcut(keyseq)
+ shortcut = action.shortcut()
+ self.assert_(isinstance(shortcut, QKeySequence))
+ self.assertEqual(shortcut.toString(), keyseq)
+
+if __name__ == '__main__':
+ unittest.main()
+
diff --git a/tests/QtGui/qstyle_test.py b/tests/QtGui/qstyle_test.py
new file mode 100755
index 0000000..da467e8
--- /dev/null
+++ b/tests/QtGui/qstyle_test.py
@@ -0,0 +1,32 @@
+
+import unittest
+from helper import UsesQApplication
+
+from PySide.QtGui import QWidget, QLabel, QFontComboBox, QStyleFactory
+
+class SetStyleTest(UsesQApplication):
+ '''Tests setting the same QStyle for all objects in a UI hierarchy.'''
+
+ def testSetStyle(self):
+ '''All this test have to do is not break with some invalid Python wrapper.'''
+
+ def setStyleHelper(widget, style):
+ widget.setStyle(style)
+ widget.setPalette(style.standardPalette())
+ for child in widget.children():
+ if isinstance(child, QWidget):
+ setStyleHelper(child, style)
+
+ container = QWidget()
+ # QFontComboBox is used because it has an QLineEdit created in C++ inside it,
+ # and if the QWidget.setStyle(style) steals the ownership of the style
+ # for the C++ originated widget everything will break.
+ fontComboBox = QFontComboBox(container)
+ label = QLabel(container)
+ label.setText('Label')
+ style = QStyleFactory.create(QStyleFactory.keys()[0])
+ setStyleHelper(container, style)
+
+if __name__ == '__main__':
+ unittest.main()
+
diff --git a/tests/QtGui/qtableview_test.py b/tests/QtGui/qtableview_test.py
new file mode 100644
index 0000000..0ea5cab
--- /dev/null
+++ b/tests/QtGui/qtableview_test.py
@@ -0,0 +1,17 @@
+
+import unittest
+
+from PySide.QtCore import QAbstractTableModel
+from PySide.QtGui import QTableWidget
+from helper import UsesQApplication
+
+class QPenTest(UsesQApplication):
+
+ def testItemModel(self):
+ tv = QTableWidget()
+
+ self.assertEqual(type(tv.model()), QAbstractTableModel)
+
+if __name__ == '__main__':
+ unittest.main()
+
diff --git a/tests/QtGui/qtabwidget_test.py b/tests/QtGui/qtabwidget_test.py
new file mode 100644
index 0000000..143f99c
--- /dev/null
+++ b/tests/QtGui/qtabwidget_test.py
@@ -0,0 +1,21 @@
+
+import unittest
+
+from PySide.QtGui import QTabWidget
+from helper import TimedQApplication
+
+class RemoveTabMethod(TimedQApplication):
+ def setUp(self):
+ TimedQApplication.setUp(self)
+ self.tab = QTabWidget()
+
+ def tearDown(self):
+ del self.tab
+ TimedQApplication.tearDown(self)
+
+
+ def testRemoveTabPresence(self):
+ self.assert_(getattr(self.tab, 'removeTab'))
+
+if __name__ == '__main__':
+ unittest.main()
diff --git a/tests/QtGui/qtextedit_test.py b/tests/QtGui/qtextedit_test.py
new file mode 100644
index 0000000..442cbe2
--- /dev/null
+++ b/tests/QtGui/qtextedit_test.py
@@ -0,0 +1,32 @@
+'''Test cases for QTextEdit and ownership problems.'''
+
+import unittest
+from sys import getrefcount
+from PySide.QtGui import QTextEdit
+
+from helper import UsesQApplication
+
+class DontTouchReference(UsesQApplication):
+ '''Check if the QTextTable returned by QTextCursor.insertTable() is not
+ referenced by the QTextCursor that returns it.'''
+
+ def setUp(self):
+ super(DontTouchReference, self).setUp()
+ self.editor = QTextEdit()
+ self.cursor = self.editor.textCursor()
+ self.table = self.cursor.insertTable(1, 1)
+
+ def testQTextTable(self):
+ # methods which return QTextTable should not increment its reference
+ self.assertEqual(getrefcount(self.table), 2)
+ f = self.cursor.currentFrame()
+ del f
+ self.assertEqual(getrefcount(self.table), 2)
+ # destroying the cursor should not raise any "RuntimeError: internal
+ # C++ object already deleted." when accessing the QTextTable
+ del self.cursor
+ self.assertEqual(getrefcount(self.table), 2)
+ cell = self.table.cellAt(0, 0)
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/tests/QtGui/qtoolbar_test.py b/tests/QtGui/qtoolbar_test.py
new file mode 100644
index 0000000..1bcf566
--- /dev/null
+++ b/tests/QtGui/qtoolbar_test.py
@@ -0,0 +1,35 @@
+
+'''Test cases for QToolbar'''
+
+import unittest
+
+from PySide.QtGui import QToolBar, QMainWindow, QAction
+
+from helper import UsesQApplication
+
+class AddActionText(UsesQApplication):
+ '''Test case for calling QToolbar.addAction passing a text'''
+
+ def setUp(self):
+ #Acquire resources
+ super(AddActionText, self).setUp()
+ self.window = QMainWindow()
+ self.toolbar = QToolBar()
+ self.window.addToolBar(self.toolbar)
+
+ def tearDown(self):
+ #Release resources
+ super(AddActionText, self).tearDown()
+ del self.toolbar
+ del self.window
+
+ def testText(self):
+ #QToolBar.addAction(text) - add a QToolButton
+ self.toolbar.addAction('aaaa')
+ self.assertEqual(len(self.toolbar.actions()), 1)
+ action = self.toolbar.actions()[0]
+ self.assert_(isinstance(action, QAction))
+ self.assertEqual(action.text(), 'aaaa')
+
+if __name__ == '__main__':
+ unittest.main()
diff --git a/tests/QtGui/qtoolbox_test.py b/tests/QtGui/qtoolbox_test.py
new file mode 100644
index 0000000..dd0d2c6
--- /dev/null
+++ b/tests/QtGui/qtoolbox_test.py
@@ -0,0 +1,31 @@
+
+import unittest
+
+from PySide.QtGui import QToolBox, QWidget, QIcon
+
+from helper import UsesQApplication
+
+class OwnershipControl(UsesQApplication):
+
+ def setUp(self):
+ super(OwnershipControl, self).setUp()
+ self.toolbox = QToolBox()
+
+ def tearDown(self):
+ del self.toolbox
+ super(OwnershipControl, self).tearDown()
+
+ def testAddItem(self):
+ # Was losing ownership of the widget.
+ index = self.toolbox.addItem(QWidget(), 'item')
+ item = self.toolbox.widget(index)
+ self.assert_(isinstance(item, QWidget))
+
+ def testAddItemWithIcon(self):
+ index = self.toolbox.addItem(QWidget(), QIcon(), 'item')
+ item = self.toolbox.widget(index)
+ self.assert_(isinstance(item, QWidget))
+
+
+if __name__ == '__main__':
+ unittest.main()
diff --git a/tests/QtGui/qvariant_test.py b/tests/QtGui/qvariant_test.py
new file mode 100644
index 0000000..138e432
--- /dev/null
+++ b/tests/QtGui/qvariant_test.py
@@ -0,0 +1,85 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+'''Test cases for QVariant with QtGui types'''
+
+import unittest
+
+from PySide.QtCore import *
+from PySide.QtGui import *
+
+from helper import UsesQApplication
+
+class Dummy(object):
+ pass
+
+class QVariantTypeName(unittest.TestCase):
+ def testQPen(self):
+ obj = QVariant(QPen(Qt.red))
+ self.assertEqual('QPen', obj.typeName())
+
+ def testQColor(self):
+ obj = QVariant(QColor(Qt.red))
+ self.assertEqual('QColor', obj.typeName())
+
+ def testGlobalColor(self):
+ obj = QVariant(Qt.red)
+ # XXX: PyQt4 returns int instead of QColor like the C++ version
+ self.assertEqual('QColor', obj.typeName())
+
+ def testEnums(self):
+ obj = QVariant(Qt.SolidLine)
+ self.assertEqual('int', obj.typeName())
+
+class QVariantQColorImplicitlyConvertion(unittest.TestCase):
+ def testConversions(self):
+ c1 = QColor(0, 0, 0)
+ v = QVariant(c1)
+ c2 = QColor(v)
+ self.assertEqual(c1, c2)
+
+class QVariantQPixmap(UsesQApplication):
+ '''QVariant(QPixmap)'''
+
+ def testBasic(self):
+ '''QVariant(QPixmap)'''
+ pixmap = QPixmap(10,20)
+ pixmap.fill(Qt.blue)
+ variant = QVariant(pixmap)
+
+ self.assertEqual(variant.typeName(), "QPixmap")
+
+ def testQObject(self):
+ obj = QObject()
+ v = QVariant(obj)
+ self.assertEqual(v.typeName(), 'QObject*')
+
+ def testQWidget(self):
+ obj = QWidget()
+ v = QVariant(obj)
+ self.assertEqual(v.typeName(), 'QWidget*')
+
+class MyColor(QColor):
+ pass
+
+class MyPrimitive(int):
+ pass
+
+class QVariantMess(unittest.TestCase):
+ def testMyColor(self):
+ c1 = MyColor()
+ v = QVariant(c1)
+ self.assertEqual(type(v.toPyObject()), MyColor)
+
+ def testMyPrimitive(self):
+ p = MyPrimitive(3)
+ v = QVariant(p)
+ self.assertNotEqual(v.type(), QVariant.Int)
+ self.assertTrue(v.toPyObject() is p)
+
+ def testMatrix2x2(self):
+ m = QMatrix2x2()
+ v = QVariant(m)
+ self.assertEqual('QMatrix2x2', v.typeName())
+
+if __name__ == '__main__':
+ unittest.main()
diff --git a/tests/QtGui/qwidget_setlayout_test.py b/tests/QtGui/qwidget_setlayout_test.py
new file mode 100644
index 0000000..c715396
--- /dev/null
+++ b/tests/QtGui/qwidget_setlayout_test.py
@@ -0,0 +1,33 @@
+#!/usr/bin/python
+
+import unittest
+
+from PySide.QtGui import QWidget, QVBoxLayout, QPushButton, QApplication, QHBoxLayout
+from helper import UsesQApplication
+
+class QWidgetTest(UsesQApplication):
+
+ def test_setLayout(self):
+ layout = QVBoxLayout()
+ btn1 = QPushButton("button_v1")
+ layout.addWidget(btn1)
+
+ btn2 = QPushButton("button_v2")
+ layout.addWidget(btn2)
+
+ layout2 = QHBoxLayout()
+
+ btn1 = QPushButton("button_h1")
+ layout2.addWidget(btn1)
+
+ btn2 = QPushButton("button_h2")
+ layout2.addWidget(btn2)
+
+ layout.addLayout(layout2)
+
+ widget = QWidget()
+ widget.setLayout(layout)
+
+if __name__ == '__main__':
+ unittest.main()
+
diff --git a/tests/QtGui/qwidget_test.py b/tests/QtGui/qwidget_test.py
new file mode 100644
index 0000000..a14311c
--- /dev/null
+++ b/tests/QtGui/qwidget_test.py
@@ -0,0 +1,30 @@
+
+import unittest
+
+from PySide.QtGui import QWidget, QMainWindow
+from helper import UsesQApplication
+
+class QWidgetInherit(QMainWindow):
+ def __init__(self):
+ QWidget.__init__(self)
+
+class QWidgetTest(UsesQApplication):
+
+ def testInheritance(self):
+ newobj = QWidgetInherit()
+ widget = QWidget()
+ newobj.setCentralWidget(widget)
+ self.assertEqual(widget, newobj.centralWidget())
+
+class QWidgetVisible(UsesQApplication):
+
+ def testBasic(self):
+ # Also related to bug #244, on existence of setVisible'''
+ widget = QWidget()
+ self.assert_(not widget.isVisible())
+ widget.setVisible(True)
+ self.assert_(widget.isVisible())
+
+
+if __name__ == '__main__':
+ unittest.main()
diff --git a/tests/QtGui/reference_count_test.py b/tests/QtGui/reference_count_test.py
new file mode 100644
index 0000000..b549868
--- /dev/null
+++ b/tests/QtGui/reference_count_test.py
@@ -0,0 +1,71 @@
+
+'''Test cases for Reference count when the object is created in c++ side'''
+
+import unittest
+
+import sys
+import weakref
+import gc
+
+
+from PySide.QtCore import Qt, QPointF
+from PySide.QtGui import QApplication, QGraphicsScene, QGraphicsRectItem, QPolygonF, QGraphicsPolygonItem, QGraphicsRectItem
+
+from helper import UsesQApplication
+
+destroyedRect = False
+destroyedPol = False
+
+def rect_del(o):
+ global destroyedRect
+ destroyedRect = True
+
+def pol_del(o):
+ global destroyedPol
+ destroyedPol = True
+
+class ReferenceCount(UsesQApplication):
+
+ def setUp(self):
+ super(ReferenceCount, self).setUp()
+ self.scene = QGraphicsScene()
+
+ def tearDown(self):
+ super(ReferenceCount, self).tearDown()
+
+ def beforeTest(self):
+ points = [QPointF(0, 0), QPointF(100, 100), QPointF(0, 100)]
+ pol = self.scene.addPolygon(QPolygonF(points))
+ self.assert_(isinstance(pol, QGraphicsPolygonItem))
+ self.wrp = weakref.ref(pol, pol_del)
+
+ #refcount need be 3 because one ref for QGraphicsScene, and one to rect obj
+ self.assertEqual(sys.getrefcount(pol), 3)
+
+ def testReferenceCount(self):
+ global destroyedRect
+ global destroyedPol
+
+ self.beforeTest()
+
+ rect = self.scene.addRect(10.0, 10.0, 10.0, 10.0)
+ self.assert_(isinstance(rect, QGraphicsRectItem))
+
+ self.wrr = weakref.ref(rect, rect_del)
+
+ #refcount need be 3 because one ref for QGraphicsScene, and one to rect obj
+ self.assertEqual(sys.getrefcount(rect), 3)
+
+ del rect
+ #not destroyed because one ref continue in QGraphicsScene
+ self.assertEqual(destroyedRect, False)
+ self.assertEqual(destroyedPol, False)
+
+ del self.scene
+
+ #QGraphicsScene was destroyed and this destroy internal ref to rect
+ self.assertEqual(destroyedRect, True)
+ self.assertEqual(destroyedPol, True)
+
+if __name__ == '__main__':
+ unittest.main()
diff --git a/tests/QtGui/sample.png b/tests/QtGui/sample.png
new file mode 100644
index 0000000..60450f0
--- /dev/null
+++ b/tests/QtGui/sample.png
Binary files differ
diff --git a/tests/QtGui/standardpixmap_test.py b/tests/QtGui/standardpixmap_test.py
new file mode 100644
index 0000000..65bd322
--- /dev/null
+++ b/tests/QtGui/standardpixmap_test.py
@@ -0,0 +1,15 @@
+
+import unittest
+
+from PySide.QtGui import QPixmap, QStyle
+
+from helper import UsesQApplication
+
+class StandardPixmapTest(UsesQApplication):
+ def testDefaultOptions(self): # Bug 253
+ pixmap = self.app.style().standardPixmap(QStyle.SP_DirClosedIcon)
+ self.assert_(isinstance(pixmap, QPixmap))
+
+if __name__ == '__main__':
+ unittest.main()
+
diff --git a/tests/QtGui/timed_app_test.py b/tests/QtGui/timed_app_test.py
new file mode 100644
index 0000000..4af9a01
--- /dev/null
+++ b/tests/QtGui/timed_app_test.py
@@ -0,0 +1,14 @@
+
+import unittest
+
+from helper import TimedQApplication
+
+class TestTimedApp(TimedQApplication):
+ '''Simple test case for TimedQApplication'''
+
+ def testFoo(self):
+ #Simple test of TimedQApplication
+ self.app.exec_()
+
+if __name__ == '__main__':
+ unittest.main()
diff --git a/tests/QtGui/virtual_protected_inheritance_test.py b/tests/QtGui/virtual_protected_inheritance_test.py
new file mode 100644
index 0000000..15de37d
--- /dev/null
+++ b/tests/QtGui/virtual_protected_inheritance_test.py
@@ -0,0 +1,70 @@
+
+'''Test cases for overriding inherited protected virtual methods'''
+
+import unittest
+
+from PySide.QtCore import QTimerEvent
+from PySide.QtGui import QApplication, QSpinBox
+
+from helper import UsesQApplication
+
+class MySpinButton(QSpinBox):
+ '''Simple example class of overriding QObject.timerEvent'''
+
+ def __init__(self, max_runs=5, app=None):
+ #Creates a new spinbox that will run <max_runs> and quit <app>
+ super(MySpinButton, self).__init__()
+
+ if app is None:
+ app = QApplication([])
+
+ self.app = app
+ self.max_runs = max_runs
+ self.runs = 0
+
+ def timerEvent(self, event):
+ #Timer event method
+ self.runs += 1
+
+ self.setValue(self.runs)
+
+ if self.runs == self.max_runs:
+ self.app.quit()
+
+ if not isinstance(event, QTimerEvent):
+ raise TypeError('Invalid event type. Must be TimerEvent')
+
+class TimerEventTest(UsesQApplication):
+ '''Test case for running QObject.timerEvent from inherited class'''
+
+ qapplication = True
+
+ def setUp(self):
+ #Acquire resources
+ super(TimerEventTest, self).setUp()
+ self.widget = MySpinButton(app=self.app)
+
+ def tearDown(self):
+ #Release resources
+ del self.widget
+ super(TimerEventTest, self).tearDown()
+
+ def testMethod(self):
+ #QWidget.timerEvent overrinding (protected inherited)
+ timer_id = self.widget.startTimer(0)
+
+ self.app.exec_()
+
+ self.widget.killTimer(timer_id)
+
+ self.assertEqual(self.widget.runs, 5)
+
+
+if __name__ == '__main__':
+ unittest.main()
+ #app = QApplication([])
+ #widget = MySpinButton(app=app)
+ #widget.startTimer(500)
+ #widget.show()
+ #app.exec_()
+
diff --git a/tests/QtGui/virtual_pure_override.py b/tests/QtGui/virtual_pure_override.py
new file mode 100644
index 0000000..c496e49
--- /dev/null
+++ b/tests/QtGui/virtual_pure_override.py
@@ -0,0 +1,48 @@
+#!/usr/bin/python
+
+import unittest
+
+from PySide.QtGui import QGraphicsScene, QGraphicsRectItem, QGraphicsView, QApplication, QBrush, QColor
+from PySide.QtCore import QTimer
+from helper import UsesQApplication
+
+qgraphics_item_painted = False
+
+class RoundRectItem(QGraphicsRectItem):
+
+ def __init__(self, x, y, w, h):
+ QGraphicsRectItem.__init__(self, x, y, w, h)
+
+ def paint(self, painter, qstyleoptiongraphicsitem, qwidget):
+ global qgraphics_item_painted
+ qgraphics_item_painted = True
+
+
+class QGraphicsItemTest(UsesQApplication):
+
+ def createRoundRect(self, scene):
+ item = RoundRectItem(10, 10, 100, 100)
+ item.setBrush(QBrush(QColor(255, 0, 0)))
+ scene.addItem(item)
+ return item
+
+ def quit_app(self):
+ self.app.quit()
+
+ def test_setParentItem(self):
+ global qgraphics_item_painted
+
+ scene = QGraphicsScene()
+ scene.addText("test")
+ view = QGraphicsView(scene)
+
+ rect = self.createRoundRect(scene)
+ view.show()
+ QTimer.singleShot(1000, self.quit_app)
+ self.app.exec_()
+ self.assert_(qgraphics_item_painted)
+
+
+if __name__ == '__main__':
+ unittest.main()
+
diff --git a/tests/QtGui/wrong_return_test.py b/tests/QtGui/wrong_return_test.py
new file mode 100644
index 0000000..d14ac9e
--- /dev/null
+++ b/tests/QtGui/wrong_return_test.py
@@ -0,0 +1,23 @@
+'''Test cases for Virtual functions with wrong return type'''
+
+import unittest
+
+from PySide import QtCore, QtGui
+
+from helper import UsesQApplication
+
+class MyWidget(QtGui.QWidget):
+ def __init__(self, parent=None):
+ super(MyWidget, self).__init__(parent)
+
+ def sizeHint(self):
+ pass
+
+class testCase(UsesQApplication):
+
+ def testVirtualReturn(self):
+ w = MyWidget()
+ self.assertRaises(TypeError, w.show)
+
+if __name__ == '__main__':
+ unittest.main()
diff --git a/tests/QtGui/x11_symbols.py b/tests/QtGui/x11_symbols.py
new file mode 100644
index 0000000..29cce15
--- /dev/null
+++ b/tests/QtGui/x11_symbols.py
@@ -0,0 +1,17 @@
+
+''' Test the presence of X11 symbols in QtGui'''
+
+import unittest
+
+from PySide.QtGui import QPixmap
+
+class X11Test(unittest.TestCase):
+
+ def test(self):
+ self.assert_('handle' in dir(QPixmap))
+ self.assert_('x11Info' in dir(QPixmap))
+ self.assert_('x11PictureHandle' in dir(QPixmap))
+ self.assert_('x11SetDefaultScreen' in dir(QPixmap))
+
+if __name__ == '__main__':
+ unittest.main()