Tests synchronized with the boost python PySide.

tests/qtcore/deletelater_test.py

@@ -0,0 +1,22 @@
+#!/usr/bin/python
+
+'''Test cases for QTimer.singleShot'''
+
+import unittest
+
+from PySide.QtCore import QObject, QTimer, QCoreApplication, SIGNAL
+from helper import UsesQCoreApplication
+
+class TestDeleteLater(UsesQCoreApplication):
+    '''Test case for function DeleteLater'''
+
+    def testCase(self):
+        o = QObject()
+        o.deleteLater()
+        del o
+        QTimer.singleShot(100, self.app.quit)
+        self.app.exec_()
+
+if __name__ == '__main__':
+    unittest.main()
+

tests/qtcore/qdate_test.py

@@ -0,0 +1,28 @@
+#!/usr/bin/python
+'''Test cases for QDate'''
+
+import unittest
+
+from PySide.QtCore import *
+
+class TestQDate (unittest.TestCase):
+    def testGetDate(self):
+        date = QDate(2009, 22, 9)
+        tuple_ = date.getDate()
+        self.assertEquals(tuple, tuple_.__class__)
+        (y, m, d) = tuple_
+        self.assertEqual(date.year(), y)
+        self.assertEqual(date.month(), m)
+        self.assertEqual(date.day(), d)
+
+    def testGetWeekNumber(self):
+        date = QDate(2000, 1, 1)
+        tuple_ = date.weekNumber()
+        self.assertEquals(tuple, tuple_.__class__)
+        (week, yearNumber) = tuple_
+        self.assertEqual(week, 52)
+        self.assertEqual(yearNumber, 1999)
+
+
+if __name__ == '__main__':
+    unittest.main()

tests/qtcore/qhandle_test.py

@@ -0,0 +1,16 @@
+#!/usr/bin/python
+'''Test cases for QEnum and QFlags'''
+
+import unittest
+
+from PySide.QtCore import QThread, Qt
+
+class TestHANDLE(unittest.TestCase):
+    def testIntConversion(self):
+        i = 0
+        h = QThread.currentThreadId()
+        i = 0 + int(h)
+        self.assertEqual(i, int(h))
+
+if __name__ == '__main__':
+    unittest.main()

tests/qtcore/qlinef_test.py

@@ -0,0 +1,20 @@
+#!/usr/bin/python
+'''Test cases for QLineF'''
+
+import unittest
+import os
+
+from PySide.QtCore import *
+
+class TestQLineF (unittest.TestCase):
+    def testIntersect(self):
+        l1 = QLineF(0, 0, 1, 0)
+        l2 = QLineF(1, -1, 1, 1)
+        tuple_ = l1.intersect(l2)
+        self.assertEquals(tuple, tuple_.__class__)
+        (value, p) = tuple_
+        self.assertEquals(QLineF.BoundedIntersection, value)
+        self.assertEqual(QPointF(1, 0), p)
+
+if __name__ == '__main__':
+    unittest.main()

tests/qtcore/qprocess_test.py

@@ -0,0 +1,18 @@
+#!/usr/bin/python
+'''Test cases for QProcess'''
+
+import unittest
+import os
+
+from PySide.QtCore import *
+
+class TestQProcess (unittest.TestCase):
+    def testStartDetached(self):
+        tuple_ = QProcess.startDetached("dir", [], os.getcwd())
+        self.assertEquals(tuple, tuple_.__class__)
+        (value, pid) = tuple_
+        self.assertEquals(bool, value.__class__)
+        self.assertEqual(long, pid.__class__)
+
+if __name__ == '__main__':
+    unittest.main()

tests/qtcore/qresource_test.py

@@ -11,11 +11,7 @@ class ResourcesUsage(unittest.TestCase):
     '''Test case for resources usage'''
 
     def setUp(self):
-        try:
-            f = open('quoteEnUS.txt')
-        except IOError:
-            f = open(os.path.join('qtcore', 'quoteEnUS.txt'))
-
+        f = open(os.path.join(os.path.dirname(__file__), 'quoteEnUS.txt'))
         self.text = f.read()
         f.close()
 

tests/qtcore/qtextstream_test.py

@@ -0,0 +1,87 @@
+
+'''Unit tests for QTextStream'''
+
+import unittest
+
+from PySide.QtCore import QTextStream, QIODevice, QString, QByteArray
+from PySide.QtCore import QTextCodec, QFile
+
+class QTextStreamShiftTest(unittest.TestCase):
+
+    def setUp(self):
+        self.ba = QByteArray()
+        self.read = QTextStream(self.ba, QIODevice.ReadOnly)
+        self.write = QTextStream(self.ba, QIODevice.WriteOnly)
+
+    def testNumber(self):
+        '''QTextStream << number'''
+
+        self.write << QString('4')
+        res = self.read.readLine()
+        self.assert_(isinstance(res, QString))
+        self.assertEqual(res, QString('4'))
+
+class QTextStreamGetSet(unittest.TestCase):
+
+    def setUp(self):
+        self.obj = QTextStream()
+
+
+    def testCodec(self):
+        '''QTextStream set/get Codec'''
+
+        codec = QTextCodec.codecForName('ISO8859-1')
+        self.obj.setCodec(codec)
+        self.assertEqual(codec, self.obj.codec())
+
+    def testDevice(self):
+        '''QTextStream get/set Device'''
+        device = QFile()
+        self.obj.setDevice(device)
+        self.assertEqual(device, self.obj.device())
+        self.obj.setDevice(None)
+        self.assertEqual(None, self.obj.device())
+
+class QTextStreamInitialization(unittest.TestCase):
+
+    def testConstruction(self):
+        '''QTextStream construction'''
+        obj = QTextStream()
+
+        self.assertEqual(obj.codec(), QTextCodec.codecForLocale())
+        self.assertEqual(obj.device(), None)
+        self.assertEqual(obj.string(), None)
+
+        self.assert_(obj.atEnd())
+        self.assertEqual(obj.readAll(), '')
+
+class QTextStreamReadLinesFromDevice(unittest.TestCase):
+
+    def _check_data(self, data_set):
+
+        for data, lines in data_set:
+            stream = QTextStream(data)
+
+            res = []
+            while not stream.atEnd():
+                res.append(stream.readLine())
+
+            self.assertEqual(res, lines)
+
+    def testLatin1(self):
+        '''QTextStream readLine for simple Latin1 strings'''
+
+        data = []
+
+        data.append((QByteArray(), []))
+        data.append((QByteArray('\n'), ['']))
+        data.append((QByteArray('\r\n'), ['']))
+        data.append((QByteArray('ole'), ['ole']))
+        data.append((QByteArray('ole\n'), ['ole']))
+        data.append((QByteArray('ole\r\n'), ['ole']))
+        data.append((QByteArray('ole\r\ndole\r\ndoffen'), ['ole', 'dole', 'doffen']))
+
+        self._check_data(data)
+
+if __name__ == '__main__':
+    unittest.main()