Remove Python2 from PySide2 tests

Task-number: PYSIDE-1339
Task-number: PYSIDE-904
Change-Id: Idc6c185c0c848476a60d91b802af760fc2b70a30
Reviewed-by: Christian Tismer <tismer@stackless.com>

44 files changed, 239 insertions, 461 deletions

diff --git a/sources/pyside2/tests/QtCore/CMakeLists.txt b/sources/pyside2/tests/QtCore/CMakeLists.txt
index 5d661dc34..98bfb9334 100644
--- a/sources/pyside2/tests/QtCore/CMakeLists.txt
+++ b/sources/pyside2/tests/QtCore/CMakeLists.txt
@@ -47,7 +47,6 @@ PYSIDE_TEST(qabs_test.py)
 PYSIDE_TEST(qabstractitemmodel_test.py)
 PYSIDE_TEST(qanimationgroup_test.py)
 PYSIDE_TEST(qbitarray_test.py)
-PYSIDE_TEST(qbytearray_buffer_protocol_test.py)
 PYSIDE_TEST(qbytearray_concatenation_operator_test.py)
 PYSIDE_TEST(qbytearray_operator_iadd_test.py)
 PYSIDE_TEST(qbytearray_operator_test.py)
diff --git a/sources/pyside2/tests/QtCore/bug_1063.py b/sources/pyside2/tests/QtCore/bug_1063.py
index 73291bffc..db55dc1e0 100644
--- a/sources/pyside2/tests/QtCore/bug_1063.py
+++ b/sources/pyside2/tests/QtCore/bug_1063.py
@@ -38,7 +38,7 @@ from init_paths import init_test_paths
 init_test_paths(False)
 
 from PySide2 import QtCore
-import py3kcompat as py3k
+
 
 class QTextStreamTestCase(unittest.TestCase):
     def setUp(self):
@@ -46,7 +46,7 @@ class QTextStreamTestCase(unittest.TestCase):
         self.temp_file.close()
         self.f = QtCore.QFile(self.temp_file.name)
         self.f.open(QtCore.QIODevice.WriteOnly)
-        self.strings = (py3k.unicode_('foo'), py3k.unicode_('bar'))
+        self.strings = ('foo', 'bar')
         self.stream = QtCore.QTextStream(self.f)
 
     def testIt(self):
diff --git a/sources/pyside2/tests/QtCore/bug_1313.py b/sources/pyside2/tests/QtCore/bug_1313.py
index a24c53b99..9f7742c84 100644
--- a/sources/pyside2/tests/QtCore/bug_1313.py
+++ b/sources/pyside2/tests/QtCore/bug_1313.py
@@ -37,7 +37,6 @@ from init_paths import init_test_paths
 init_test_paths(False)
 
 from PySide2 import QtCore
-import py3kcompat as py3k
 
 
 class MyQObject(QtCore.QObject):
@@ -51,11 +50,9 @@ async def demo_coroutine():
 """
 
 
-if py3k.IS_PY3K:
-    exec(demo_coroutine_definition_code)
+exec(demo_coroutine_definition_code)
 
 
-@unittest.skipIf(not py3k.IS_PY3K, "Requires Python 3 due to use of async def")
 class CoroutineRaisesStopIterationTestCase(unittest.TestCase):
     def setUp(self):
         self.coroutine = demo_coroutine()
diff --git a/sources/pyside2/tests/QtCore/bug_938.py b/sources/pyside2/tests/QtCore/bug_938.py
index bbac1845b..4e70a8604 100644
--- a/sources/pyside2/tests/QtCore/bug_938.py
+++ b/sources/pyside2/tests/QtCore/bug_938.py
@@ -35,14 +35,14 @@ from init_paths import init_test_paths
 init_test_paths(False)
 
 from PySide2.QtCore import *
-import py3kcompat as py3k
+
 
 class TestBug938 (unittest.TestCase):
 
     def testIt(self):
         b = QBuffer()
         b.open(QBuffer.WriteOnly)
-        b.write(py3k.b("\x0023\x005"))
+        b.write(bytes("\x0023\x005", "UTF-8"))
         b.close()
         self.assertEqual(b.buffer().size(), 5)
 
diff --git a/sources/pyside2/tests/QtCore/bug_994.py b/sources/pyside2/tests/QtCore/bug_994.py
index 1a9649a10..5465f4e01 100644
--- a/sources/pyside2/tests/QtCore/bug_994.py
+++ b/sources/pyside2/tests/QtCore/bug_994.py
@@ -34,16 +34,15 @@ sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 from init_paths import init_test_paths
 init_test_paths(False)
 
-import py3kcompat as py3k
 from PySide2.QtCore import QIODevice, QTextStream
 
 
 class MyIODevice (QIODevice):
     def readData(self, amount):
-        return py3k.b("\0a" * int(amount/2))
+        return bytes("\0a" * int(amount/2), "UTF-8")
 
     def readLineData(self, maxSize):
-        return py3k.b("\0b" * 4)
+        return bytes("\0b" * 4, "UTF-8")
 
     def atEnd(self):
         return False
diff --git a/sources/pyside2/tests/QtCore/deepcopy_test.py b/sources/pyside2/tests/QtCore/deepcopy_test.py
index ab17a2e14..2fafea354 100644
--- a/sources/pyside2/tests/QtCore/deepcopy_test.py
+++ b/sources/pyside2/tests/QtCore/deepcopy_test.py
@@ -37,7 +37,6 @@ init_test_paths(False)
 
 from PySide2.QtCore import QByteArray, QDate, QDateTime, QTime, QLine, QLineF
 from PySide2.QtCore import Qt, QSize, QSizeF, QRect, QRectF, QDir, QPoint, QPointF
-import py3kcompat as py3k
 try:
     from PySide2.QtCore import QUuid
     HAVE_Q = True
@@ -52,7 +51,7 @@ class DeepCopyHelper:
 
 class QByteArrayDeepCopy(DeepCopyHelper, unittest.TestCase):
     def setUp(self):
-        self.original = QByteArray(py3k.b('the quick brown fox jumps over the lazy dog'))
+        self.original = QByteArray(bytes('the quick brown fox jumps over the lazy dog', "UTF-8"))
 
 
 class QDateDeepCopy(DeepCopyHelper, unittest.TestCase):
diff --git a/sources/pyside2/tests/QtCore/qbytearray_buffer_protocol_test.py b/sources/pyside2/tests/QtCore/qbytearray_buffer_protocol_test.py
deleted file mode 100644
index 20f8fa915..000000000
--- a/sources/pyside2/tests/QtCore/qbytearray_buffer_protocol_test.py
+++ /dev/null
@@ -1,60 +0,0 @@
-#!/usr/bin/python
-# -*- coding: utf-8 -*-
-
-#############################################################################
-##
-## Copyright (C) 2016 The Qt Company Ltd.
-## Contact: https://www.qt.io/licensing/
-##
-## This file is part of the test suite of Qt for Python.
-##
-## $QT_BEGIN_LICENSE:GPL-EXCEPT$
-## Commercial License Usage
-## Licensees holding valid commercial Qt licenses may use this file in
-## accordance with the commercial license agreement provided with the
-## Software or, alternatively, in accordance with the terms contained in
-## a written agreement between you and The Qt Company. For licensing terms
-## and conditions see https://www.qt.io/terms-conditions. For further
-## information use the contact form at https://www.qt.io/contact-us.
-##
-## GNU General Public License Usage
-## Alternatively, this file may be used under the terms of the GNU
-## General Public License version 3 as published by the Free Software
-## Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
-## included in the packaging of this file. Please review the following
-## information to ensure the GNU General Public License requirements will
-## be met: https://www.gnu.org/licenses/gpl-3.0.html.
-##
-## $QT_END_LICENSE$
-##
-#############################################################################
-
-'''Tests QByteArray implementation of Python buffer protocol'''
-
-import os
-from os.path import isdir
-import sys
-import unittest
-
-sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-from init_paths import init_test_paths
-init_test_paths(False)
-
-import py3kcompat as py3k
-
-from PySide2.QtCore import QByteArray
-
-
-class QByteArrayBufferProtocolTest(unittest.TestCase):
-    '''Tests QByteArray implementation of Python buffer protocol'''
-
-    def testQByteArrayBufferProtocol(self):
-        if py3k.IS_PY3K:
-            return
-        #Tests QByteArray implementation of Python buffer protocol using the os.path.isdir
-        #function which an unicode object or other object implementing the Python buffer protocol
-        isdir(QByteArray('/tmp'))
-
-if __name__ == '__main__':
-    unittest.main()
-
diff --git a/sources/pyside2/tests/QtCore/qbytearray_concatenation_operator_test.py b/sources/pyside2/tests/QtCore/qbytearray_concatenation_operator_test.py
index 1375c3ab3..6d369bf0b 100644
--- a/sources/pyside2/tests/QtCore/qbytearray_concatenation_operator_test.py
+++ b/sources/pyside2/tests/QtCore/qbytearray_concatenation_operator_test.py
@@ -40,25 +40,25 @@ from init_paths import init_test_paths
 init_test_paths(False)
 
 from PySide2.QtCore import QByteArray
-import py3kcompat as py3k
+
 
 class QByteArrayConcatenationOperatorTest(unittest.TestCase):
     '''Test cases for QByteArray concatenation with '+' operator'''
 
     def testConcatQByteArrayAndPythonString(self):
         #Test concatenation of a QByteArray with a Python bytes, in this order
-        qba = QByteArray(py3k.b('foo'))
-        result = qba + py3k.b('\x00bar')
+        qba = QByteArray(bytes('foo', "UTF-8"))
+        result = qba + bytes('\x00bar', "UTF-8")
         self.assertEqual(type(result), QByteArray)
-        self.assertEqual(result, py3k.b('foo\x00bar'))
+        self.assertEqual(result, bytes('foo\x00bar', "UTF-8"))
 
     def testConcatPythonStringAndQByteArray(self):
         #Test concatenation of a Python bytes with a QByteArray, in this order
         concat_python_string_add_qbytearray_worked = True
-        qba = QByteArray(py3k.b('foo'))
-        result = py3k.b('bar\x00') + qba
+        qba = QByteArray(bytes('foo', "UTF-8"))
+        result = bytes('bar\x00', "UTF-8") + qba
         self.assertEqual(type(result), QByteArray)
-        self.assertEqual(result, py3k.b('bar\x00foo'))
+        self.assertEqual(result, bytes('bar\x00foo', "UTF-8"))
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/sources/pyside2/tests/QtCore/qbytearray_operator_iadd_test.py b/sources/pyside2/tests/QtCore/qbytearray_operator_iadd_test.py
index d0a65465b..da9ca5b38 100644
--- a/sources/pyside2/tests/QtCore/qbytearray_operator_iadd_test.py
+++ b/sources/pyside2/tests/QtCore/qbytearray_operator_iadd_test.py
@@ -36,7 +36,7 @@ init_test_paths(False)
 
 from PySide2.QtCore import QByteArray
 from helper.docmodifier import DocModifier
-import py3kcompat as py3k
+
 
 class BaseQByteArrayOperatorIAdd(object):
     '''Base class for QByteArray += operator tests.
@@ -49,21 +49,21 @@ class BaseQByteArrayOperatorIAdd(object):
 
     def testSingleString(self):
         '''QByteArray += bytes of size 1'''
-        s = py3k.b('0')
+        s = bytes('0', "UTF-8")
         self.obj += s
         self.assertEqual(self.obj, self.orig_obj + s)
         self.assertEqual(self.obj.size(), self.orig_obj.size() + len(s))
 
     def testString(self):
         '''QByteArray += bytes of size > 1'''
-        s = bytearray(py3k.b('dummy'))
+        s = bytearray(bytes('dummy', "UTF-8"))
         self.obj += s # XXx iadd support abytearray
         self.assertEqual(self.obj, self.orig_obj + s)
         self.assertEqual(self.obj.size(), self.orig_obj.size() + len(s))
 
     def testQByteArray(self):
         '''QByteArray += QByteArray'''
-        s = QByteArray(py3k.b('array'))
+        s = QByteArray(bytes('array', "UTF-8"))
         self.obj += s
         self.assertEqual(self.obj, self.orig_obj + s)
 
@@ -86,8 +86,8 @@ class ValidQByteArrayOperatorIAdd(unittest.TestCase, BaseQByteArrayOperatorIAdd)
     doc_filter = lambda x: x.startswith('test')
 
     def setUp(self):
-        self.obj = QByteArray(py3k.b('some byte array'))
-        self.orig_obj = QByteArray(py3k.b('some byte array'))
+        self.obj = QByteArray(bytes('some byte array', "UTF-8"))
+        self.orig_obj = QByteArray(bytes('some byte array', "UTF-8"))
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/sources/pyside2/tests/QtCore/qbytearray_operator_test.py b/sources/pyside2/tests/QtCore/qbytearray_operator_test.py
index b19179429..01000341c 100644
--- a/sources/pyside2/tests/QtCore/qbytearray_operator_test.py
+++ b/sources/pyside2/tests/QtCore/qbytearray_operator_test.py
@@ -39,8 +39,6 @@ sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 from init_paths import init_test_paths
 init_test_paths(False)
 
-import py3kcompat as py3k
-
 from PySide2.QtCore import QByteArray
 
 class QByteArrayOperatorEqual(unittest.TestCase):
@@ -54,12 +52,12 @@ class QByteArrayOperatorEqual(unittest.TestCase):
 
     def testSimple(self):
         #QByteArray(some_string) == QByteArray(some_string)
-        string = py3k.b('egg snakes')
+        string = bytes('egg snakes', "UTF-8")
         self.assertEqual(QByteArray(string), QByteArray(string))
 
     def testPyString(self):
         #QByteArray(string) == string
-        string = py3k.b('my test string')
+        string = bytes('my test string', "UTF-8")
         self.assertEqual(QByteArray(string), string)
 
 class QByteArrayOperatorAt(unittest.TestCase):
@@ -68,30 +66,30 @@ class QByteArrayOperatorAt(unittest.TestCase):
     def testInRange(self):
         #QByteArray[x] where x is a valid index
         string = 'abcdefgh'
-        obj = QByteArray(py3k.b(string))
+        obj = QByteArray(bytes(string, "UTF-8"))
 
         for i in range(len(string)):
-            self.assertEqual(obj[i], py3k.b(string[i]))
+            self.assertEqual(obj[i], bytes(string[i], "UTF-8"))
 
     def testInRangeReverse(self):
         #QByteArray[x] where x is a valid index (reverse order)
         string = 'abcdefgh'
-        obj = QByteArray(py3k.b(string))
+        obj = QByteArray(bytes(string, "UTF-8"))
 
         for i in range(len(string)-1, 0, -1):
-            self.assertEqual(obj[i], py3k.b(string[i]))
+            self.assertEqual(obj[i], bytes(string[i], "UTF-8"))
 
 
     def testOutOfRange(self):
         #QByteArray[x] where x is out of index
-        string = py3k.b('1234567')
+        string = bytes('1234567', "UTF-8")
         obj = QByteArray(string)
         self.assertRaises(IndexError, lambda :obj[len(string)])
 
     def testNullStrings(self):
-        ba = QByteArray(py3k.b('\x00'))
+        ba = QByteArray(bytes('\x00', "UTF-8"))
         self.assertEqual(ba.at(0), '\x00')
-        self.assertEqual(ba[0], py3k.b('\x00'))
+        self.assertEqual(ba[0], bytes('\x00', "UTF-8"))
 
 class QByteArrayOperatorLen(unittest.TestCase):
     '''Test case for __len__ operator of QByteArray'''
@@ -99,9 +97,9 @@ class QByteArrayOperatorLen(unittest.TestCase):
     def testBasic(self):
         '''QByteArray __len__'''
         self.assertEqual(len(QByteArray()), 0)
-        self.assertEqual(len(QByteArray(py3k.b(''))), 0)
-        self.assertEqual(len(QByteArray(py3k.b(' '))), 1)
-        self.assertEqual(len(QByteArray(py3k.b('yabadaba'))), 8)
+        self.assertEqual(len(QByteArray(bytes('', "UTF-8"))), 0)
+        self.assertEqual(len(QByteArray(bytes(' ', "UTF-8"))), 1)
+        self.assertEqual(len(QByteArray(bytes('yabadaba', "UTF-8"))), 8)
 
 
 class QByteArrayOperatorStr(unittest.TestCase):
@@ -110,8 +108,8 @@ class QByteArrayOperatorStr(unittest.TestCase):
     def testBasic(self):
         '''QByteArray __str__'''
         self.assertEqual(QByteArray().__str__(), str(b''))
-        self.assertEqual(QByteArray(py3k.b('')).__str__(), str(b''))
-        self.assertEqual(QByteArray(py3k.b('aaa')).__str__(), str(b'aaa'))
+        self.assertEqual(QByteArray(bytes('', "UTF-8")).__str__(), str(b''))
+        self.assertEqual(QByteArray(bytes('aaa', "UTF-8")).__str__(), str(b'aaa'))
 
 
 if __name__ == '__main__':
diff --git a/sources/pyside2/tests/QtCore/qbytearray_test.py b/sources/pyside2/tests/QtCore/qbytearray_test.py
index 5202569f1..529941706 100644
--- a/sources/pyside2/tests/QtCore/qbytearray_test.py
+++ b/sources/pyside2/tests/QtCore/qbytearray_test.py
@@ -41,32 +41,31 @@ sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 from init_paths import init_test_paths
 init_test_paths(False)
 
-import py3kcompat as py3k
 
 from PySide2.QtCore import QByteArray, QSettings, QObject, QDataStream, QIODevice
 
 class QByteArrayTestToNumber(unittest.TestCase):
     def testToNumberInt(self):
-        obj = QByteArray(py3k.b('37'))
+        obj = QByteArray(bytes('37', "UTF8"))
         self.assertEqual((37, True), obj.toInt())
 
     def testToNumberUShort(self):
-        obj = QByteArray(py3k.b('37'))
+        obj = QByteArray(bytes('37', "UTF8"))
         self.assertEqual((37, True), obj.toUShort())
 
     def testToNumberFloat(self):
-        obj = QByteArray(py3k.b('37.109'))
+        obj = QByteArray(bytes('37.109', "UTF8"))
         self.assertEqual((ctypes.c_float(37.109).value, True),
                          obj.toFloat())
 
     def testToNumberDouble(self):
-        obj = QByteArray(py3k.b('37.109'))
+        obj = QByteArray(bytes('37.109', "UTF8"))
         self.assertEqual((ctypes.c_double(37.109).value, True),
                          obj.toDouble())
 
     def testSetNum(self):
         b = QByteArray()
-        b.setNum(py3k.long(-124124))
+        b.setNum(int(-124124))
         self.assertEqual(b, "-124124")
         b = QByteArray()
         b.setNum(-124124)
@@ -76,7 +75,7 @@ class QByteArrayTestToNumber(unittest.TestCase):
         self.assertEqual(b, "-0.5")
 
     def testNumber(self):
-        b = QByteArray.number(py3k.long(-124124))
+        b = QByteArray.number(int(-124124))
         self.assertEqual(b, "-124124")
         b = QByteArray.number(-124124)
         self.assertEqual(b, "-124124")
@@ -85,9 +84,9 @@ class QByteArrayTestToNumber(unittest.TestCase):
 
     def testAppend(self):
         b = QByteArray()
-        b.append(py3k.b("A"))
+        b.append(bytes("A", "UTF8"))
         self.assertEqual(b.size(), 1)
-        b.append(py3k.b("AB"))
+        b.append(bytes("AB", "UTF8"))
         self.assertEqual(b.size(), 3)
 
 
@@ -96,7 +95,7 @@ class QByteArraySplit(unittest.TestCase):
 
     def testPathSeparator(self):
         #QByteArray.split('/')
-        obj = QByteArray(py3k.b(unittest.__file__))
+        obj = QByteArray(bytes(unittest.__file__, "UTF8"))
         self.assertEqual(obj.split('/'), unittest.__file__.split('/'))
 
 class QByteArrayData(unittest.TestCase):
@@ -104,14 +103,14 @@ class QByteArrayData(unittest.TestCase):
     '''Test case for QByteArray.data'''
 
     def testData(self):
-        url = QByteArray(py3k.b("http://pyside.org"))
-        self.assertEqual(url.data(), py3k.b("http://pyside.org"))
+        url = QByteArray(bytes("http://pyside.org", "UTF8"))
+        self.assertEqual(url.data(), bytes("http://pyside.org", "UTF8"))
 
     def testDataWithZeros(self):
-        s1 = py3k.b("123\000321")
+        s1 = bytes("123\000321", "UTF8")
         ba = QByteArray(s1)
         s2 = ba.data()
-        self.assertEqual(py3k.b(s1), s2)
+        self.assertEqual(s1, s2)
         self.assertEqual(s1, ba)
 
 class QByteArrayOperatorAtSetter(unittest.TestCase):
@@ -119,9 +118,9 @@ class QByteArrayOperatorAtSetter(unittest.TestCase):
 
     def testSetterString(self):
         '''QByteArray[x] = pythonstring'''
-        obj = QByteArray(py3k.b('123456'))
-        obj[1] = py3k.b('0')
-        self.assertEqual(obj, QByteArray(py3k.b('103456')))
+        obj = QByteArray(bytes('123456', "UTF8"))
+        obj[1] = bytes('0', "UTF8")
+        self.assertEqual(obj, QByteArray(bytes('103456', "UTF8")))
 
 class QByteArrayOnQDataStream(unittest.TestCase):
     '''
@@ -139,11 +138,9 @@ class TestBug664(unittest.TestCase):
     QByteArray.data() should return correct data
     '''
     def testIt(self):
-        a = QByteArray(py3k.unicode_('hi 猫').encode('utf-8'))
-        if py3k.IS_PY3K:
-            self.assertEqual(repr(a), "PySide2.QtCore.QByteArray(b'hi \\xe7\\x8c\\xab')")
-        else:
-            self.assertEqual(repr(a), "PySide2.QtCore.QByteArray('hi \\xe7\\x8c\\xab')")
+        a = QByteArray(bytes('hi 猫', "UTF-8"))
+        self.assertEqual(repr(a), "PySide2.QtCore.QByteArray(b'hi \\xe7\\x8c\\xab')")
+
 
 class QByteArrayOnQVariant(unittest.TestCase):
     def testQByteArrayOnQVariant(self):
@@ -155,7 +152,7 @@ class TestBug567(unittest.TestCase):
     QByteArray should support slices
     '''
     def testIt(self):
-        ba = QByteArray(py3k.b('1234567890'))
+        ba = QByteArray(bytes('1234567890', "UTF8"))
         self.assertEqual(ba[2:4], '34')
         self.assertEqual(ba[:4], '1234')
         self.assertEqual(ba[4:], '567890')
@@ -168,114 +165,111 @@ class TestBug567(unittest.TestCase):
 
 class TestPickler(unittest.TestCase):
     def testIt(self):
-        ba = QByteArray(py3k.b("321\x00123"))
+        ba = QByteArray(bytes("321\x00123", "UTF8"))
         output = pickle.dumps(str(ba))
         ba2 = pickle.loads(output)
         self.assertEqual(str(ba), str(ba2))
 
 class QByteArrayBug720(unittest.TestCase):
     def testIt(self):
-        ba = QByteArray(py3k.b("32\"1\x00123"))
-        self.assertEqual(str(ba), str(py3k.b("32\"1\x00123")))
-        if py3k.IS_PY3K:
-            self.assertEqual(repr(ba), "PySide2.QtCore.QByteArray(b'32\"1\\x00123')")
-        else:
-            self.assertEqual(repr(ba), "PySide2.QtCore.QByteArray('32\"1\\x00123')")
+        ba = QByteArray(bytes("32\"1\x00123", "UTF8"))
+        self.assertEqual(str(ba), str(bytes("32\"1\x00123", "UTF-8")))
+        self.assertEqual(repr(ba), "PySide2.QtCore.QByteArray(b'32\"1\\x00123')")
 
 class QByteArrayImplicitConvert(unittest.TestCase):
     def testString(self):
         # No implicit conversions from QByteArray to python string
-        ba = QByteArray(py3k.b("object name"))
+        ba = QByteArray(bytes("object name", "UTF8"))
         obj = QObject()
         self.assertRaises(TypeError, obj.setObjectName, ba)
 
 
 class QByteArraySliceAssignment(unittest.TestCase):
     def testIndexAssignment(self):
-        a = QByteArray(py3k.b('abc'))
-        a[0] = py3k.b('x')
-        self.assertEqual(a[0], py3k.b('x'))
+        a = QByteArray(bytes('abc', "UTF8"))
+        a[0] = bytes('x', "UTF8")
+        self.assertEqual(a[0], bytes('x', "UTF8"))
 
         def test_1():
-            a[0] = py3k.b('xy')
+            a[0] = bytes('xy', "UTF8")
         self.assertRaises(ValueError, test_1)
 
     def testSliceAssignmentBytes(self):
-        b = QByteArray(py3k.b('0123456789'))
-        b[2:8] = py3k.b('abcdef')
-        self.assertEqual(b[2:8], py3k.b('abcdef'))
+        b = QByteArray(bytes('0123456789', "UTF8"))
+        b[2:8] = bytes('abcdef', "UTF8")
+        self.assertEqual(b[2:8], bytes('abcdef', "UTF8"))
         # Delete behavior
         b[2:8] = None
-        self.assertEqual(b, py3k.b('0189'))
+        self.assertEqual(b, bytes('0189', "UTF8"))
 
         # number of slots and number of values doesn't match
         def test_2():
-            b[2:8:2] = py3k.b('')
+            b[2:8:2] = bytes('', "UTF8")
         self.assertRaises(ValueError, test_2)
-        b = QByteArray(py3k.b('0123456789'))
+        b = QByteArray(bytes('0123456789', "UTF8"))
         # reverse slice
-        b[5:2:-1] = py3k.b('ABC')
-        self.assertEqual(b, py3k.b('012CBA6789'))
+        b[5:2:-1] = bytes('ABC', "UTF8")
+        self.assertEqual(b, bytes('012CBA6789', "UTF8"))
         # step is not 1
-        b[2:9:3] = py3k.b('XYZ')
-        self.assertEqual(b, py3k.b('01XCBY67Z9'))
-        b = QByteArray(py3k.b('0123456789'))
-        b[9:2:-3] = py3k.b('XYZ')
-        self.assertEqual(b, py3k.b('012Z45Y78X'))
+        b[2:9:3] = bytes('XYZ', "UTF8")
+        self.assertEqual(b, bytes('01XCBY67Z9', "UTF8"))
+        b = QByteArray(bytes('0123456789', "UTF8"))
+        b[9:2:-3] = bytes('XYZ', "UTF8")
+        self.assertEqual(b, bytes('012Z45Y78X', "UTF8"))
 
     def testSliceAssignmentQByteArray(self):
-        b = QByteArray(py3k.b('0123456789'))
-        b[2:8] = QByteArray(py3k.b('abcdef'))
-        self.assertEqual(b[2:8], py3k.b('abcdef'))
+        b = QByteArray(bytes('0123456789', "UTF8"))
+        b[2:8] = QByteArray(bytes('abcdef', "UTF8"))
+        self.assertEqual(b[2:8], bytes('abcdef', "UTF8"))
         # shrink
-        b[2:8] = QByteArray(py3k.b('aaa'))
-        self.assertEqual(b, py3k.b('01aaa89'))
+        b[2:8] = QByteArray(bytes('aaa', "UTF8"))
+        self.assertEqual(b, bytes('01aaa89', "UTF8"))
         # expanse
-        b[2:5] = QByteArray(py3k.b('uvwxyz'))
-        self.assertEqual(b, py3k.b('01uvwxyz89'))
+        b[2:5] = QByteArray(bytes('uvwxyz', "UTF8"))
+        self.assertEqual(b, bytes('01uvwxyz89', "UTF8"))
         # Delete behavior
         b[2:8] = QByteArray()
-        self.assertEqual(b, py3k.b('0189'))
+        self.assertEqual(b, bytes('0189', "UTF8"))
 
-        b = QByteArray(py3k.b('0123456789'))
+        b = QByteArray(bytes('0123456789', "UTF8"))
         # reverse assginment
-        b[5:2:-1] = QByteArray(py3k.b('ABC'))
-        self.assertEqual(b, py3k.b('012CBA6789'))
+        b[5:2:-1] = QByteArray(bytes('ABC', "UTF8"))
+        self.assertEqual(b, bytes('012CBA6789', "UTF8"))
         # step is not 1
-        b[2:9:3] = QByteArray(py3k.b('XYZ'))
-        self.assertEqual(b, py3k.b('01XCBY67Z9'))
-        b = QByteArray(py3k.b('0123456789'))
-        b[9:2:-3] = QByteArray(py3k.b('XYZ'))
-        self.assertEqual(b, py3k.b('012Z45Y78X'))
+        b[2:9:3] = QByteArray(bytes('XYZ', "UTF8"))
+        self.assertEqual(b, bytes('01XCBY67Z9', "UTF8"))
+        b = QByteArray(bytes('0123456789', "UTF8"))
+        b[9:2:-3] = QByteArray(bytes('XYZ', "UTF8"))
+        self.assertEqual(b, bytes('012Z45Y78X', "UTF8"))
 
     def testSliceAssignmentByteArray(self):
-        b = QByteArray(py3k.b('0123456789'))
+        b = QByteArray(bytes('0123456789', "UTF8"))
         # replace
-        b[2:8] = bytearray(py3k.b('abcdef'))
-        self.assertEqual(b[2:8], py3k.b('abcdef'))
+        b[2:8] = bytearray(bytes('abcdef', "UTF8"))
+        self.assertEqual(b[2:8], bytes('abcdef', "UTF8"))
         # shrink
-        b[2:8] = bytearray(py3k.b('aaa'))
-        self.assertEqual(b, py3k.b('01aaa89'))
+        b[2:8] = bytearray(bytes('aaa', "UTF8"))
+        self.assertEqual(b, bytes('01aaa89', "UTF8"))
         # expanse
-        b[2:5] = bytearray(py3k.b('uvwxyz'))
-        self.assertEqual(b, py3k.b('01uvwxyz89'))
+        b[2:5] = bytearray(bytes('uvwxyz', "UTF8"))
+        self.assertEqual(b, bytes('01uvwxyz89', "UTF8"))
         # Delete behavior
-        b[2:8] = bytearray(py3k.b(''))
-        self.assertEqual(b, py3k.b('0189'))
+        b[2:8] = bytearray(bytes('', "UTF8"))
+        self.assertEqual(b, bytes('0189', "UTF8"))
 
-        b = QByteArray(py3k.b('0123456789'))
+        b = QByteArray(bytes('0123456789', "UTF8"))
         # reverse assginment
-        b[5:2:-1] = bytearray(py3k.b('ABC'))
-        self.assertEqual(b, py3k.b('012CBA6789'))
+        b[5:2:-1] = bytearray(bytes('ABC', "UTF8"))
+        self.assertEqual(b, bytes('012CBA6789', "UTF8"))
         # step is not 1
-        b[2:9:3] = bytearray(py3k.b('XYZ'))
-        self.assertEqual(b, py3k.b('01XCBY67Z9'))
-        b = QByteArray(py3k.b('0123456789'))
-        b[9:2:-3] = bytearray(py3k.b('XYZ'))
-        self.assertEqual(b, py3k.b('012Z45Y78X'))
+        b[2:9:3] = bytearray(bytes('XYZ', "UTF8"))
+        self.assertEqual(b, bytes('01XCBY67Z9', "UTF8"))
+        b = QByteArray(bytes('0123456789', "UTF8"))
+        b[9:2:-3] = bytearray(bytes('XYZ', "UTF8"))
+        self.assertEqual(b, bytes('012Z45Y78X', "UTF8"))
 
     def testBufferProtocol(self):
-        orig_bytes = py3k.b('0123456789')
+        orig_bytes = bytes('0123456789', "UTF8")
         byte_array = QByteArray(orig_bytes)
         actual_bytes = bytes(byte_array)
         self.assertEqual(orig_bytes, actual_bytes)
diff --git a/sources/pyside2/tests/QtCore/qdatastream_test.py b/sources/pyside2/tests/QtCore/qdatastream_test.py
index a2d2908b2..495af6233 100644
--- a/sources/pyside2/tests/QtCore/qdatastream_test.py
+++ b/sources/pyside2/tests/QtCore/qdatastream_test.py
@@ -38,8 +38,6 @@ sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 from init_paths import init_test_paths
 init_test_paths(False)
 
-import py3kcompat as py3k
-
 from PySide2.QtCore import QBitArray, QByteArray, QIODevice, QDataStream, QDate, QTime, QDateTime
 
 def create_bitarray(string):
@@ -115,32 +113,32 @@ class QDataStreamShift(unittest.TestCase):
         self.stream.writeQChar(42)
 
         res = self.read_stream.readQChar()
-        self.assertEqual(res, py3k.unichr(42))
+        self.assertEqual(res, chr(42))
 
     def testQCharNull(self):
         '''QDataStream <<>> QChar - null'''
         self.stream.writeQChar(None)
 
         res = self.read_stream.readQChar()
-        self.assertEqual(res, py3k.unicode_('\x00'))
+        self.assertEqual(res, '\x00')
 
     def testQByteArrayValid(self):
         '''QDataStream <<>> QByteArray - valid'''
-        self.stream << QByteArray(py3k.b("hello"))
+        self.stream << QByteArray(bytes("hello", "UTF-8"))
 
         res = QByteArray()
 
         self.read_stream >> res
-        self.assertEqual(res, QByteArray(py3k.b("hello")))
+        self.assertEqual(res, QByteArray(bytes("hello", "UTF-8")))
 
     def testQByteArrayEmpty(self):
         '''QDataStream <<>> QByteArray - empty'''
-        self.stream << QByteArray(py3k.b(""))
+        self.stream << QByteArray(bytes("", "UTF-8"))
 
         res = QByteArray()
 
         self.read_stream >> res
-        self.assertEqual(res, QByteArray(py3k.b("")))
+        self.assertEqual(res, QByteArray(bytes("", "UTF-8")))
         self.assertTrue(res.isEmpty())
         self.assertFalse(res.isNull())
 
@@ -160,21 +158,21 @@ class QDataStreamShift(unittest.TestCase):
         self.stream.writeQString('Ka-boom')
 
         res = self.read_stream.readQString()
-        self.assertEqual(res, py3k.unicode_('Ka-boom'))
+        self.assertEqual(res, 'Ka-boom')
 
     def testQStringEmpty(self):
         '''QDataStream <<>> QString - empty'''
         self.stream.writeQString('')
 
         res = self.read_stream.readQString()
-        self.assertEqual(res, py3k.unicode_(''))
+        self.assertEqual(res, '')
 
     def testQStringNull(self):
         '''QDataStream <<>> QString - null'''
         self.stream.writeQString(None)
 
         res = self.read_stream.readQString()
-        self.assertEqual(res, py3k.unicode_(''))
+        self.assertEqual(res, '')
 
     def testQBitArrayNull(self):
         '''QDataStream <<>> QBitArray - null'''
@@ -284,29 +282,29 @@ class QDataStreamShiftBitArray(unittest.TestCase):
         '''QDataStream with valid QBitArray'''
         data = []
 
-        data.append((QByteArray(py3k.b('\x00\x00\x00\x00')), QDataStream.Ok,
+        data.append((QByteArray(bytes('\x00\x00\x00\x00', "UTF-8")), QDataStream.Ok,
                      QBitArray()))
-        data.append((QByteArray(py3k.b('\x00\x00\x00\x01\x00')), QDataStream.Ok,
+        data.append((QByteArray(bytes('\x00\x00\x00\x01\x00', "UTF-8")), QDataStream.Ok,
                      create_bitarray('0')))
-        data.append((QByteArray(py3k.b('\x00\x00\x00\x01\x01')), QDataStream.Ok,
+        data.append((QByteArray(bytes('\x00\x00\x00\x01\x01', "UTF-8")), QDataStream.Ok,
                      create_bitarray('1')))
-        data.append((QByteArray(py3k.b('\x00\x00\x00\x02\x03')), QDataStream.Ok,
+        data.append((QByteArray(bytes('\x00\x00\x00\x02\x03', "UTF-8")), QDataStream.Ok,
                      create_bitarray('11')))
-        data.append((QByteArray(py3k.b('\x00\x00\x00\x03\x07')), QDataStream.Ok,
+        data.append((QByteArray(bytes('\x00\x00\x00\x03\x07', "UTF-8")), QDataStream.Ok,
                      create_bitarray('111')))
-        data.append((QByteArray(py3k.b('\x00\x00\x00\x04\x0f')), QDataStream.Ok,
+        data.append((QByteArray(bytes('\x00\x00\x00\x04\x0f', "UTF-8")), QDataStream.Ok,
                      create_bitarray('1111')))
-        data.append((QByteArray(py3k.b('\x00\x00\x00\x05\x1f')), QDataStream.Ok,
+        data.append((QByteArray(bytes('\x00\x00\x00\x05\x1f', "UTF-8")), QDataStream.Ok,
                      create_bitarray('11111')))
-        data.append((QByteArray(py3k.b('\x00\x00\x00\x06\x3f')), QDataStream.Ok,
+        data.append((QByteArray(bytes('\x00\x00\x00\x06\x3f', "UTF-8")), QDataStream.Ok,
                      create_bitarray('111111')))
-        data.append((QByteArray(py3k.b('\x00\x00\x00\x07\x7f')), QDataStream.Ok,
+        data.append((QByteArray(bytes('\x00\x00\x00\x07\x7f', "UTF-8")), QDataStream.Ok,
                      create_bitarray('1111111')))
-        data.append((QByteArray(py3k.b('\x00\x00\x00\x07\x7e')), QDataStream.Ok,
+        data.append((QByteArray(bytes('\x00\x00\x00\x07\x7e', "UTF-8")), QDataStream.Ok,
                      create_bitarray('0111111')))
-        data.append((QByteArray(py3k.b('\x00\x00\x00\x07\x00')), QDataStream.Ok,
+        data.append((QByteArray(bytes('\x00\x00\x00\x07\x00', "UTF-8")), QDataStream.Ok,
                      create_bitarray('0000000')))
-        data.append((QByteArray(py3k.b('\x00\x00\x00\x07\x39')), QDataStream.Ok,
+        data.append((QByteArray(bytes('\x00\x00\x00\x07\x39', "UTF-8")), QDataStream.Ok,
                      create_bitarray('1001110')))
 
         self._check_bitarray(data)
@@ -317,19 +315,19 @@ class QDataStreamShiftBitArray(unittest.TestCase):
 
         data.append((QByteArray(), QDataStream.ReadPastEnd,
                      QBitArray()))
-        data.append((QByteArray(py3k.b('\x00')), QDataStream.ReadPastEnd,
+        data.append((QByteArray(bytes('\x00', "UTF-8")), QDataStream.ReadPastEnd,
                      QBitArray()))
-        data.append((QByteArray(py3k.b('\x00\x00')), QDataStream.ReadPastEnd,
+        data.append((QByteArray(bytes('\x00\x00', "UTF-8")), QDataStream.ReadPastEnd,
                      QBitArray()))
-        data.append((QByteArray(py3k.b('\x00\x00\x00')), QDataStream.ReadPastEnd,
+        data.append((QByteArray(bytes('\x00\x00\x00', "UTF-8")), QDataStream.ReadPastEnd,
                      QBitArray()))
-        data.append((QByteArray(py3k.b('\x00\x00\x00\x01')), QDataStream.ReadPastEnd,
+        data.append((QByteArray(bytes('\x00\x00\x00\x01', "UTF-8")), QDataStream.ReadPastEnd,
                      QBitArray()))
-        data.append((QByteArray(py3k.b('\x00\x00\x00\x02')), QDataStream.ReadPastEnd,
+        data.append((QByteArray(bytes('\x00\x00\x00\x02', "UTF-8")), QDataStream.ReadPastEnd,
                      QBitArray()))
-        data.append((QByteArray(py3k.b('\x00\x00\x00\x03')), QDataStream.ReadPastEnd,
+        data.append((QByteArray(bytes('\x00\x00\x00\x03', "UTF-8")), QDataStream.ReadPastEnd,
                      QBitArray()))
-        data.append((QByteArray(py3k.b('\x00\x00\x00\x04')), QDataStream.ReadPastEnd,
+        data.append((QByteArray(bytes('\x00\x00\x00\x04', "UTF-8")), QDataStream.ReadPastEnd,
                      QBitArray()))
 
         self._check_bitarray(data)
@@ -338,7 +336,7 @@ class QDataStreamShiftBitArray(unittest.TestCase):
         '''QDataStream reading corrupt data'''
         data = []
 
-        data.append((QByteArray(py3k.b('\x00\x00\x00\x01\x02')),
+        data.append((QByteArray(bytes('\x00\x00\x00\x01\x02', "UTF-8")),
                      QDataStream.ReadCorruptData,
                      QBitArray()))
 
@@ -352,10 +350,10 @@ class QDataStreamRawData(unittest.TestCase):
         ba = QByteArray()
         data = QDataStream(ba, QIODevice.WriteOnly)
         data.writeRawData('AB\x00C')
-        self.assertEqual(ba.data(), py3k.b('AB\x00C'))
+        self.assertEqual(ba.data(), bytes('AB\x00C', "UTF-8"))
 
         data = QDataStream(ba)
-        self.assertEqual(data.readRawData(4), py3k.b('AB\x00C'))
+        self.assertEqual(data.readRawData(4), bytes('AB\x00C', "UTF-8"))
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/sources/pyside2/tests/QtCore/qfile_test.py b/sources/pyside2/tests/QtCore/qfile_test.py
index 960d0d1d8..57f9f4ee8 100644
--- a/sources/pyside2/tests/QtCore/qfile_test.py
+++ b/sources/pyside2/tests/QtCore/qfile_test.py
@@ -35,8 +35,6 @@ sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 from init_paths import init_test_paths
 init_test_paths(False)
 
-import py3kcompat as py3k
-
 from PySide2.QtCore import QDir, QFile, QIODevice, QSaveFile, QTemporaryDir
 
 class GetCharTest(unittest.TestCase):
@@ -45,7 +43,7 @@ class GetCharTest(unittest.TestCase):
     def setUp(self):
         '''Acquire resources'''
         handle, self.filename = tempfile.mkstemp()
-        os.write(handle, py3k.b('a'))
+        os.write(handle, bytes('a', "UTF-8"))
         os.close(handle)
 
     def tearDown(self):
@@ -71,7 +69,7 @@ class GetCharTest(unittest.TestCase):
             if sys.version_info[0] >= 3:
                 self.assertEqual(memory[0], ord('a'))
             else:
-                self.assertEqual(memory[0], py3k.b('a'))
+                self.assertEqual(memory[0], bytes('a', "UTF-8"))
             # now memory points to wild bytes... :-)
             # uncommenting this must cause a segfault.
             # self.assertEqual(memory[0], 'a')
@@ -84,7 +82,7 @@ class GetCharTest(unittest.TestCase):
         self.assertTrue(dir.isValid())
         saveFile = QSaveFile(dir.path() + "/test.dat")
         self.assertTrue(saveFile.open(QIODevice.WriteOnly))
-        saveFile.write(py3k.b("Test"))
+        saveFile.write(bytes("Test", "UTF-8"))
         self.assertTrue(saveFile.commit())
         self.assertTrue(os.path.exists(QDir.toNativeSeparators(saveFile.fileName())))
 
diff --git a/sources/pyside2/tests/QtCore/qfileread_test.py b/sources/pyside2/tests/QtCore/qfileread_test.py
index 1a9afd1ab..291bf6f54 100644
--- a/sources/pyside2/tests/QtCore/qfileread_test.py
+++ b/sources/pyside2/tests/QtCore/qfileread_test.py
@@ -35,7 +35,7 @@ from init_paths import init_test_paths
 init_test_paths(False)
 
 from PySide2.QtCore import QIODevice, QTemporaryFile
-import py3kcompat as py3k
+
 
 class FileChild1(QTemporaryFile):
     pass
@@ -53,11 +53,11 @@ class readDataTest(unittest.TestCase):
         '''Acquire resources'''
         self.filename1 = FileChild1()
         self.assertTrue(self.filename1.open())
-        self.filename1.write(py3k.b('Test text for testing'))
+        self.filename1.write(bytes('Test text for testing', "UTF-8"))
 
         self.filename2 = FileChild2()
         self.assertTrue(self.filename2.open())
-        self.filename2.write(py3k.b('Test text for testing'))
+        self.filename2.write(bytes('Test text for testing', "UTF-8"))
 
     def tearDown(self):
         '''release resources'''
diff --git a/sources/pyside2/tests/QtCore/qjsondocument_test.py b/sources/pyside2/tests/QtCore/qjsondocument_test.py
index 3f8a9c848..8ce56d6b9 100644
--- a/sources/pyside2/tests/QtCore/qjsondocument_test.py
+++ b/sources/pyside2/tests/QtCore/qjsondocument_test.py
@@ -39,24 +39,18 @@ from init_paths import init_test_paths
 init_test_paths(False)
 
 from PySide2.QtCore import QJsonDocument
-import py3kcompat as py3k
+
 
 class QJsonDocumentTest(unittest.TestCase):
 
     def testToVariant(self):
         a = QJsonDocument.fromJson(b'{"test": null}')
         self.assertIsInstance(a, QJsonDocument)
-        if py3k.IS_PY3K:
-            self.assertEqual(str(a.toVariant()), "{'test': None}")
-        else:
-            self.assertEqual(str(a.toVariant()), "{u'test': None}")
+        self.assertEqual(str(a.toVariant()), "{'test': None}")
 
         b = QJsonDocument.fromJson(b'{"test": [null]}')
         self.assertIsInstance(b, QJsonDocument)
-        if py3k.IS_PY3K:
-            self.assertEqual(str(b.toVariant()), "{'test': [None]}")
-        else:
-            self.assertEqual(str(b.toVariant()), "{u'test': [None]}")
+        self.assertEqual(str(b.toVariant()), "{'test': [None]}")
 
 
 if __name__ == '__main__':
diff --git a/sources/pyside2/tests/QtCore/qmessageauthenticationcode_test.py b/sources/pyside2/tests/QtCore/qmessageauthenticationcode_test.py
index 225807b9e..52838c95e 100644
--- a/sources/pyside2/tests/QtCore/qmessageauthenticationcode_test.py
+++ b/sources/pyside2/tests/QtCore/qmessageauthenticationcode_test.py
@@ -39,11 +39,10 @@ from init_paths import init_test_paths
 init_test_paths(False)
 
 from PySide2.QtCore import QCryptographicHash, QMessageAuthenticationCode
-import py3kcompat as py3k
 
 class TestQMessageAuthenticationCode (unittest.TestCase):
     def test(self):
-        code = QMessageAuthenticationCode(QCryptographicHash.Sha1, py3k.b('bla'))
+        code = QMessageAuthenticationCode(QCryptographicHash.Sha1, bytes('bla', "UTF-8"))
         result = code.result()
         self.assertTrue(result.size() > 0)
         print(result.toHex())
diff --git a/sources/pyside2/tests/QtCore/qobject_test.py b/sources/pyside2/tests/QtCore/qobject_test.py
index dd577ecdc..47a9869d7 100644
--- a/sources/pyside2/tests/QtCore/qobject_test.py
+++ b/sources/pyside2/tests/QtCore/qobject_test.py
@@ -39,8 +39,6 @@ sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 from init_paths import init_test_paths
 init_test_paths(False)
 
-import py3kcompat as py3k
-
 from PySide2.QtCore import QObject, Signal, Qt
 
 class Obj(QObject):
@@ -73,7 +71,7 @@ class ObjectNameCase(unittest.TestCase):
         self.assertEqual('', obj.objectName())
 
     def testUnicode(self):
-        name = py3k.unicode_('não')
+        name = 'não'
         #FIXME Strange error on upstream when using equal(name, obj)
         obj = QObject()
         obj.setObjectName(name)
diff --git a/sources/pyside2/tests/QtCore/qprocess_test.py b/sources/pyside2/tests/QtCore/qprocess_test.py
index eb5753f45..2e0ad3807 100644
--- a/sources/pyside2/tests/QtCore/qprocess_test.py
+++ b/sources/pyside2/tests/QtCore/qprocess_test.py
@@ -38,15 +38,13 @@ sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 from init_paths import init_test_paths
 init_test_paths(False)
 
-import py3kcompat as py3k
-
 from PySide2.QtCore import *
 
 class TestQProcess (unittest.TestCase):
     def testStartDetached(self):
         value, pid = QProcess.startDetached("dir", [], os.getcwd())
         self.assertTrue(isinstance(value, bool))
-        self.assertTrue(isinstance(pid, py3k.long))
+        self.assertTrue(isinstance(pid, int))
 
     def testPid(self):
         p = QProcess()
diff --git a/sources/pyside2/tests/QtCore/qsettings_test.py b/sources/pyside2/tests/QtCore/qsettings_test.py
index 639f6d276..814053a85 100644
--- a/sources/pyside2/tests/QtCore/qsettings_test.py
+++ b/sources/pyside2/tests/QtCore/qsettings_test.py
@@ -37,7 +37,6 @@ from init_paths import init_test_paths
 init_test_paths(False)
 
 from helper.helper import adjust_filename
-import py3kcompat as py3k
 from PySide2.QtCore import QSettings
 
 class TestQSettings(unittest.TestCase):
@@ -49,10 +48,7 @@ class TestQSettings(unittest.TestCase):
         self.assertEqual(type(r), list)
 
         r = settings.value('var2')
-        if py3k.IS_PY3K:
-            self.assertEqual(type(r), str)
-        else:
-            self.assertEqual(type(r), unicode)
+        self.assertEqual(type(r), str)
 
         r = settings.value('var2', type=list)
         self.assertEqual(type(r), list)
diff --git a/sources/pyside2/tests/QtCore/qstring_test.py b/sources/pyside2/tests/QtCore/qstring_test.py
index c415fdc3d..59512b5a3 100644
--- a/sources/pyside2/tests/QtCore/qstring_test.py
+++ b/sources/pyside2/tests/QtCore/qstring_test.py
@@ -39,7 +39,6 @@ sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 from init_paths import init_test_paths
 init_test_paths(False)
 
-import py3kcompat as py3k
 from PySide2.QtCore import QObject
 
 class QStringConstructor(unittest.TestCase):
@@ -48,11 +47,11 @@ class QStringConstructor(unittest.TestCase):
     def testQStringDefault(self):
         obj = QObject()
         obj.setObjectName('foo')
-        self.assertEqual(obj.objectName(), py3k.unicode_('foo'))
-        obj.setObjectName(py3k.unicode_('áâãà'))
-        self.assertEqual(obj.objectName(), py3k.unicode_('áâãà'))
+        self.assertEqual(obj.objectName(), 'foo')
+        obj.setObjectName('áâãà')
+        self.assertEqual(obj.objectName(), 'áâãà')
         obj.setObjectName(None)
-        self.assertEqual(obj.objectName(), py3k.unicode_(''))
+        self.assertEqual(obj.objectName(), '')
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/sources/pyside2/tests/QtCore/qtextstream_test.py b/sources/pyside2/tests/QtCore/qtextstream_test.py
index d4bbd8479..99c231eec 100644
--- a/sources/pyside2/tests/QtCore/qtextstream_test.py
+++ b/sources/pyside2/tests/QtCore/qtextstream_test.py
@@ -36,8 +36,6 @@ sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 from init_paths import init_test_paths
 init_test_paths(False)
 
-import py3kcompat as py3k
-
 from PySide2.QtCore import QByteArray, QTextStream, QIODevice, QFile
 
 class QTextStreamShiftTest(unittest.TestCase):
@@ -53,7 +51,7 @@ class QTextStreamShiftTest(unittest.TestCase):
         self.write << '4'
         self.write.flush()
         res = self.read.readLine()
-        self.assertTrue(isinstance(res, py3k.unicode))
+        self.assertTrue(isinstance(res, str))
         self.assertEqual(res, '4')
 
 class QTextStreamGetSet(unittest.TestCase):
@@ -100,12 +98,12 @@ class QTextStreamReadLinesFromDevice(unittest.TestCase):
         data = []
 
         data.append((QByteArray(), []))
-        data.append((QByteArray(py3k.b('\n')), ['']))
-        data.append((QByteArray(py3k.b('\r\n')), ['']))
-        data.append((QByteArray(py3k.b('ole')), ['ole']))
-        data.append((QByteArray(py3k.b('ole\n')), ['ole']))
-        data.append((QByteArray(py3k.b('ole\r\n')), ['ole']))
-        data.append((QByteArray(py3k.b('ole\r\ndole\r\ndoffen')), ['ole', 'dole', 'doffen']))
+        data.append((QByteArray(bytes('\n', "UTF-8")), ['']))
+        data.append((QByteArray(bytes('\r\n', "UTF-8")), ['']))
+        data.append((QByteArray(bytes('ole', "UTF-8")), ['ole']))
+        data.append((QByteArray(bytes('ole\n', "UTF-8")), ['ole']))
+        data.append((QByteArray(bytes('ole\r\n', "UTF-8")), ['ole']))
+        data.append((QByteArray(bytes('ole\r\ndole\r\ndoffen', "UTF-8")), ['ole', 'dole', 'doffen']))
 
         self._check_data(data)
 
diff --git a/sources/pyside2/tests/QtCore/qtimezone_test.py b/sources/pyside2/tests/QtCore/qtimezone_test.py
index 8c960371f..f22ce73f9 100644
--- a/sources/pyside2/tests/QtCore/qtimezone_test.py
+++ b/sources/pyside2/tests/QtCore/qtimezone_test.py
@@ -35,11 +35,10 @@ from init_paths import init_test_paths
 init_test_paths(False)
 
 from PySide2.QtCore import QTimeZone
-import py3kcompat as py3k
 
 class TestQTimeZone (unittest.TestCase):
     def testTimeZone(self):
-        id = py3k.b('Europe/Berlin')
+        id = bytes('Europe/Berlin', "UTF-8")
         timeZone = QTimeZone(id)
         self.assertTrue(timeZone.isValid())
         self.assertEqual(timeZone.id(), id)
diff --git a/sources/pyside2/tests/QtCore/repr_test.py b/sources/pyside2/tests/QtCore/repr_test.py
index 71bab8330..8a3a1519a 100644
--- a/sources/pyside2/tests/QtCore/repr_test.py
+++ b/sources/pyside2/tests/QtCore/repr_test.py
@@ -37,7 +37,6 @@ init_test_paths(False)
 import PySide2
 from PySide2.QtCore import QByteArray, QDate, QDateTime, QTime, QLine, QLineF
 from PySide2.QtCore import Qt, QSize, QSizeF, QRect, QRectF, QPoint, QPointF
-import py3kcompat as py3k
 try:
     from PySide2.QtCore import QUuid
     HAVE_Q = True
@@ -52,7 +51,7 @@ class ReprCopyHelper:
 
 class QByteArrayReprCopy(ReprCopyHelper, unittest.TestCase):
     def setUp(self):
-        self.original = QByteArray(py3k.b('the quick brown fox jumps over the lazy dog'))
+        self.original = QByteArray(bytes('the quick brown fox jumps over the lazy dog', "UTF-8"))
 
 
 class QDateReprCopy(ReprCopyHelper, unittest.TestCase):
diff --git a/sources/pyside2/tests/QtCore/translation_test.py b/sources/pyside2/tests/QtCore/translation_test.py
index 0f36067bd..beca3a717 100644
--- a/sources/pyside2/tests/QtCore/translation_test.py
+++ b/sources/pyside2/tests/QtCore/translation_test.py
@@ -39,7 +39,6 @@ sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 from init_paths import init_test_paths
 init_test_paths(False)
 
-import py3kcompat as py3k
 from PySide2.QtCore import QObject, QTranslator, QCoreApplication
 
 from helper.usesqcoreapplication import UsesQCoreApplication
@@ -59,7 +58,7 @@ class TranslationTest(UsesQCoreApplication):
 
         obj = QObject()
         obj.setObjectName(obj.tr('Hello World!'))
-        self.assertEqual(obj.objectName(), py3k.unicode_('Orbis, te saluto!'))
+        self.assertEqual(obj.objectName(), 'Orbis, te saluto!')
 
     def testRussian(self):
         #Set string value to Russian
@@ -69,7 +68,7 @@ class TranslationTest(UsesQCoreApplication):
 
         obj = QObject()
         obj.setObjectName(obj.tr('Hello World!'))
-        self.assertEqual(obj.objectName(), py3k.unicode_('привет мир!'))
+        self.assertEqual(obj.objectName(), 'привет мир!')
 
     def testUtf8(self):
         translator = QTranslator()
@@ -78,12 +77,12 @@ class TranslationTest(UsesQCoreApplication):
 
         obj = QObject()
         obj.setObjectName(obj.tr('Hello World!'))
-        self.assertEqual(obj.objectName(), py3k.unicode_('привет мир!'))
+        self.assertEqual(obj.objectName(), 'привет мир!')
 
     def testTranslateWithNoneDisambiguation(self):
         value = 'String here'
         obj = QCoreApplication.translate('context', value, None)
-        self.assertTrue(isinstance(obj, py3k.unicode))
+        self.assertTrue(isinstance(obj, str))
         self.assertEqual(obj, value)
 
 if __name__ == '__main__':
diff --git a/sources/pyside2/tests/QtCore/unicode_test.py b/sources/pyside2/tests/QtCore/unicode_test.py
index 3f1a4d8dc..28bbafbb0 100644
--- a/sources/pyside2/tests/QtCore/unicode_test.py
+++ b/sources/pyside2/tests/QtCore/unicode_test.py
@@ -39,8 +39,6 @@ sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 from init_paths import init_test_paths
 init_test_paths(False)
 
-import py3kcompat as py3k
-
 from PySide2.QtCore import QObject
 from PySide2.QtCore import QByteArray
 
@@ -57,13 +55,13 @@ class UnicodeConversion(unittest.TestCase):
         #Set regular Python string retrieve unicode
         obj = QObject()
         obj.setObjectName('test')
-        self.assertEqual(obj.objectName(), py3k.unicode_('test'))
+        self.assertEqual(obj.objectName(), 'test')
 
     def testSetUnicodeRetrieveUnicode(self):
         #Set Python unicode string and retrieve unicode
         obj = QObject()
-        obj.setObjectName(py3k.unicode_('ümlaut'))
-        self.assertEqual(obj.objectName(), py3k.unicode_('ümlaut'))
+        obj.setObjectName('ümlaut')
+        self.assertEqual(obj.objectName(), 'ümlaut')
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/sources/pyside2/tests/QtGui/bug_660.py b/sources/pyside2/tests/QtGui/bug_660.py
index 058364d1d..066387498 100644
--- a/sources/pyside2/tests/QtGui/bug_660.py
+++ b/sources/pyside2/tests/QtGui/bug_660.py
@@ -34,7 +34,6 @@ sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 from init_paths import init_test_paths
 init_test_paths(False)
 
-import py3kcompat as py3k
 from PySide2.QtGui import QStandardItemModel, QStandardItem
 
 class MyItemModel(QStandardItemModel):
@@ -44,12 +43,12 @@ class MyItemModel(QStandardItemModel):
 
     def mimeTypes(self):
         mtypes = super(MyItemModel,self).mimeTypes()
-        mtypes.append(py3k.unicode_('application/my-form'))
+        mtypes.append('application/my-form')
         return mtypes
 
     def mimeData(self,indexes):
         self.__mimedata = super(MyItemModel,self).mimeData(indexes)
-        self.__mimedata.setData(py3k.unicode_('application/my-form'), py3k.b('hi'))
+        self.__mimedata.setData('application/my-form',bytes('hi', "UTF-8"))
         return self.__mimedata
 
 class TestBug660(unittest.TestCase):
diff --git a/sources/pyside2/tests/QtGui/bug_740.py b/sources/pyside2/tests/QtGui/bug_740.py
index a4db6e5a8..456749eaa 100644
--- a/sources/pyside2/tests/QtGui/bug_740.py
+++ b/sources/pyside2/tests/QtGui/bug_740.py
@@ -34,14 +34,13 @@ sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 from init_paths import init_test_paths
 init_test_paths(False)
 
-import py3kcompat as py3k
 from helper.usesqapplication import UsesQApplication
 from PySide2.QtCore import QSize
 from PySide2.QtGui import QBitmap, QImage
 
 class TestQBitmap(UsesQApplication):
     def testFromDataMethod(self):
-        dataBits = py3k.b('\x38\x28\x38\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\xfe\xfe\x7c\x7c\x38\x38\x10\x10')
+        dataBits = bytes('\x38\x28\x38\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\x10\xfe\xfe\x7c\x7c\x38\x38\x10\x10', "UTF-8")
         bim = QBitmap.fromData(QSize(8, 48), dataBits, QImage.Format_Mono) # missing function
 
 if __name__ == '__main__':
diff --git a/sources/pyside2/tests/QtGui/pyside_reload_test.py b/sources/pyside2/tests/QtGui/pyside_reload_test.py
index f3c7c3e8d..75994f4e4 100644
--- a/sources/pyside2/tests/QtGui/pyside_reload_test.py
+++ b/sources/pyside2/tests/QtGui/pyside_reload_test.py
@@ -26,6 +26,8 @@
 ##
 #############################################################################
 
+import importlib
+import importlib.util
 import os
 import shutil
 import sys
@@ -35,7 +37,6 @@ sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 from init_paths import init_test_paths
 init_test_paths(False)
 
-import py3kcompat as py3k
 
 orig_path = os.path.join(os.path.dirname(__file__))
 workdir = os.getcwd()
@@ -45,11 +46,8 @@ shutil.copyfile(src, dst)
 sys.path.append(workdir)
 
 def reload_module(moduleName):
-    if py3k.IS_PY3K:
-        import importlib
-        importlib.reload(moduleName)
-    else:
-        reload(moduleName)
+    importlib.reload(moduleName)
+
 
 def increment_module_value():
     modfile = open(dst, 'a')
@@ -57,11 +55,8 @@ def increment_module_value():
     modfile.flush()
     modfile.close()
     if not sys.dont_write_bytecode:
-        if py3k.IS_PY3K:
-            import importlib.util
-            cacheFile = importlib.util.cache_from_source(dst)
-        else:
-            cacheFile = dst + 'c'
+        import importlib.util
+        cacheFile = importlib.util.cache_from_source(dst)
         os.remove(cacheFile)
 
 class TestModuleReloading(unittest.TestCase):
diff --git a/sources/pyside2/tests/QtGui/qtextdocumentwriter_test.py b/sources/pyside2/tests/QtGui/qtextdocumentwriter_test.py
index d9d96dd34..7c825b62f 100644
--- a/sources/pyside2/tests/QtGui/qtextdocumentwriter_test.py
+++ b/sources/pyside2/tests/QtGui/qtextdocumentwriter_test.py
@@ -36,7 +36,7 @@ init_test_paths(False)
 
 from PySide2.QtGui import QTextDocumentWriter, QTextDocument
 from PySide2.QtCore import QBuffer
-import py3kcompat as py3k
+
 
 class QTextDocumentWriterTest(unittest.TestCase):
 
@@ -45,7 +45,7 @@ class QTextDocumentWriterTest(unittest.TestCase):
         doc = QTextDocument(text)
         b = QBuffer()
         b.open(QBuffer.ReadWrite)
-        writer = QTextDocumentWriter(b, py3k.b("plaintext"));
+        writer = QTextDocumentWriter(b, bytes("plaintext", "UTF-8"));
         writer.write(doc);
         b.close()
         self.assertEqual(b.buffer(), text)
diff --git a/sources/pyside2/tests/QtNetwork/bug_1084.py b/sources/pyside2/tests/QtNetwork/bug_1084.py
index d2c273fca..cd8dd7621 100644
--- a/sources/pyside2/tests/QtNetwork/bug_1084.py
+++ b/sources/pyside2/tests/QtNetwork/bug_1084.py
@@ -37,7 +37,7 @@ from init_paths import init_test_paths
 init_test_paths(False)
 
 from PySide2 import QtNetwork
-import py3kcompat as py3k
+
 
 class QTcpSocketTestCase(unittest.TestCase):
     def setUp(self):
@@ -45,7 +45,7 @@ class QTcpSocketTestCase(unittest.TestCase):
         self.sock.connectToHost('127.0.0.1', 25)
 
     def testIt(self):
-        self.sock.write(py3k.b('quit'))
+        self.sock.write(bytes('quit', "UTF-8"))
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/sources/pyside2/tests/QtNetwork/bug_446.py b/sources/pyside2/tests/QtNetwork/bug_446.py
index e94bef510..7e7242515 100644
--- a/sources/pyside2/tests/QtNetwork/bug_446.py
+++ b/sources/pyside2/tests/QtNetwork/bug_446.py
@@ -38,11 +38,11 @@ from PySide2.QtCore import *
 from PySide2.QtNetwork import *
 
 from helper.usesqcoreapplication import UsesQCoreApplication
-import py3kcompat as py3k
+
 
 class HttpSignalsCase(UsesQCoreApplication):
     '''Test case for launching QHttp signals'''
-    DATA = py3k.b("PySide rocks")
+    DATA = bytes("PySide rocks", "UTF-8")
 
     def onError(self):
         self.assertTrue(False)
diff --git a/sources/pyside2/tests/QtNetwork/udpsocket_test.py b/sources/pyside2/tests/QtNetwork/udpsocket_test.py
index da5a21c29..7ef567294 100644
--- a/sources/pyside2/tests/QtNetwork/udpsocket_test.py
+++ b/sources/pyside2/tests/QtNetwork/udpsocket_test.py
@@ -38,7 +38,7 @@ init_test_paths(False)
 
 from PySide2.QtCore import QUrl, QObject, SIGNAL, QCoreApplication, QTimer
 from PySide2.QtNetwork import QUdpSocket, QHostAddress
-import py3kcompat as py3k
+
 
 class HttpSignalsCase(unittest.TestCase):
     '''Test case for bug #124 - readDatagram signature
@@ -64,7 +64,7 @@ class HttpSignalsCase(unittest.TestCase):
 
     def sendPackage(self):
         addr = QHostAddress(QHostAddress.LocalHost)
-        self.socket.writeDatagram(py3k.b('datagram'), addr, 45454)
+        self.socket.writeDatagram(bytes('datagram', "UTF-8"), addr, 45454)
 
     def callback(self):
         while self.server.hasPendingDatagrams():
diff --git a/sources/pyside2/tests/QtSql/qvarianttype_test.py b/sources/pyside2/tests/QtSql/qvarianttype_test.py
index 3175a178f..05d456e28 100644
--- a/sources/pyside2/tests/QtSql/qvarianttype_test.py
+++ b/sources/pyside2/tests/QtSql/qvarianttype_test.py
@@ -35,16 +35,15 @@ sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 from init_paths import init_test_paths
 init_test_paths(False)
 
-import py3kcompat as py3k
 from PySide2.QtSql import QSqlField
 
 class QVariantTypeTest(unittest.TestCase):
     def testQVariantType(self):
         f = QSqlField("name", str)
-        self.assertEqual(f.type(), py3k.unicode)
+        self.assertEqual(f.type(), str)
 
         f = QSqlField("name", "QString")
-        self.assertEqual(f.type(),  py3k.unicode)
+        self.assertEqual(f.type(),  str)
 
         f = QSqlField("name", "double")
         self.assertEqual(f.type(), float)
@@ -55,13 +54,6 @@ class QVariantTypeTest(unittest.TestCase):
         f = QSqlField("name", int)
         self.assertEqual(f.type(), int)
 
-        if not py3k.IS_PY3K:
-            f = QSqlField("name", long)
-            self.assertEqual(f.type(), int) # long isn't registered in QVariant:Type, just in QMetaType::Type
-
-        #f = QSqlField("name", QObject)
-        #self.assertEqual(f.type(), None)
-
         f = QSqlField("name", None)
         self.assertEqual(f.type(), None)
 
diff --git a/sources/pyside2/tests/QtWebEngineCore/web_engine_custom_scheme.py b/sources/pyside2/tests/QtWebEngineCore/web_engine_custom_scheme.py
index 190810edb..9604e957c 100644
--- a/sources/pyside2/tests/QtWebEngineCore/web_engine_custom_scheme.py
+++ b/sources/pyside2/tests/QtWebEngineCore/web_engine_custom_scheme.py
@@ -42,7 +42,6 @@ from PySide2.QtWebEngine import QtWebEngine
 from PySide2.QtWebEngineWidgets import QWebEngineView, QWebEngineProfile
 from PySide2.QtWebEngineCore import (QWebEngineUrlScheme,
                                      QWebEngineUrlSchemeHandler)
-import py3kcompat as py3k
 
 class TestSchemeHandler(QWebEngineUrlSchemeHandler):
     def requestStarted(self, request):
@@ -51,9 +50,9 @@ class TestSchemeHandler(QWebEngineUrlSchemeHandler):
             return
 
         self.buffer = QBuffer()
-        self.buffer.setData(py3k.b("Really nice goodbye text."))
+        self.buffer.setData(bytes("Really nice goodbye text.", "UTF-8"))
         self.buffer.aboutToClose.connect(self.buffer.deleteLater)
-        request.reply(py3k.b("text/plain;charset=utf-8"), self.buffer)
+        request.reply(bytes("text/plain;charset=utf-8", "UTF-8"), self.buffer)
 
 
 class MainTest(unittest.TestCase):
@@ -64,7 +63,7 @@ class MainTest(unittest.TestCase):
         QtWebEngine.initialize()
         app = QApplication([])
 
-        scheme_name = py3k.b("testpy")
+        scheme_name = bytes("testpy", "UTF-8")
         scheme = QWebEngineUrlScheme(scheme_name)
         scheme.setSyntax(QWebEngineUrlScheme.Syntax.Path)
         QWebEngineUrlScheme.registerScheme(scheme)
diff --git a/sources/pyside2/tests/QtWidgets/qabstracttextdocumentlayout_test.py b/sources/pyside2/tests/QtWidgets/qabstracttextdocumentlayout_test.py
index 8e291bb63..8699c7971 100644
--- a/sources/pyside2/tests/QtWidgets/qabstracttextdocumentlayout_test.py
+++ b/sources/pyside2/tests/QtWidgets/qabstracttextdocumentlayout_test.py
@@ -34,8 +34,6 @@ sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 from init_paths import init_test_paths
 init_test_paths(False)
 
-import py3kcompat as py3k
-
 from PySide2.QtCore import QSizeF, QTimer
 from PySide2.QtGui import QTextFormat, QTextCharFormat, QPyTextObject
 from PySide2.QtWidgets import QTextEdit
@@ -60,7 +58,7 @@ class QAbstractTextDocumentLayoutTest(UsesQApplication):
         fmt.setObjectType(QAbstractTextDocumentLayoutTest.objectType)
 
         cursor = self.textEdit.textCursor()
-        cursor.insertText(py3k.unichr(0xfffc), fmt)
+        cursor.insertText(chr(0xfffc), fmt)
         self.textEdit.setTextCursor(cursor)
         self.textEdit.close()
 
diff --git a/sources/pyside2/tests/QtWidgets/qimage_test.py b/sources/pyside2/tests/QtWidgets/qimage_test.py
index 8bb83c51a..11b9d2193 100644
--- a/sources/pyside2/tests/QtWidgets/qimage_test.py
+++ b/sources/pyside2/tests/QtWidgets/qimage_test.py
@@ -36,7 +36,6 @@ sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 from init_paths import init_test_paths
 init_test_paths(False)
 
-import py3kcompat as py3k
 from PySide2.QtGui import *
 from PySide2.QtWidgets import *
 from helper.helper import adjust_filename
@@ -292,17 +291,11 @@ class QImageTest(UsesQApplication):
         data2 = img1.scanLine(0)
         self.assertEqual(data1, data2)
 
-        # PySide python 3.x does not support slice yet
-        if not py3k.IS_PY3K:
-            buff = py3k.buffer(img0.bits()[:img0.bytesPerLine()])
-            self.assertEqual(data1, buff)
-            self.assertEqual(data2, buff)
-
     def testEmptyBuffer(self):
-        img = QImage(py3k.buffer(''), 100, 100, QImage.Format_ARGB32)
+        img = QImage(bytes('', "UTF-8"), 100, 100, QImage.Format_ARGB32)
 
     def testEmptyStringAsBuffer(self):
-        img = QImage(py3k.b(''), 100, 100, QImage.Format_ARGB32)
+        img = QImage(bytes('', "UTF-8"), 100, 100, QImage.Format_ARGB32)
 
     def testXpmConstructor(self):
         label = QLabel()
diff --git a/sources/pyside2/tests/QtWidgets/qstring_qkeysequence_test.py b/sources/pyside2/tests/QtWidgets/qstring_qkeysequence_test.py
index 79842aac2..a8b572d05 100644
--- a/sources/pyside2/tests/QtWidgets/qstring_qkeysequence_test.py
+++ b/sources/pyside2/tests/QtWidgets/qstring_qkeysequence_test.py
@@ -39,7 +39,6 @@ sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 from init_paths import init_test_paths
 init_test_paths(False)
 
-import py3kcompat as py3k
 from helper.usesqapplication import UsesQApplication
 
 from PySide2.QtGui import QAction, QKeySequence
@@ -56,7 +55,7 @@ class QStringQKeySequenceTest(UsesQApplication):
 
     def testPythonStringAsQKeySequence(self):
         '''Passes a Python string to an argument expecting a QKeySequence.'''
-        keyseq = py3k.unicode_('Ctrl+A')
+        keyseq = 'Ctrl+A'
         action = QAction(None)
         action.setShortcut(keyseq)
         shortcut = action.shortcut()
diff --git a/sources/pyside2/tests/QtWidgets/wrong_return_test.py b/sources/pyside2/tests/QtWidgets/wrong_return_test.py
index d95ae7639..27b5309e9 100644
--- a/sources/pyside2/tests/QtWidgets/wrong_return_test.py
+++ b/sources/pyside2/tests/QtWidgets/wrong_return_test.py
@@ -37,7 +37,6 @@ sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 from init_paths import init_test_paths
 init_test_paths(False)
 
-import py3kcompat as py3k
 from PySide2 import QtWidgets
 from helper.usesqapplication import UsesQApplication
 
@@ -56,10 +55,7 @@ class testCase(UsesQApplication):
 
     def testVirtualReturn(self):
         w = MyWidget()
-        if py3k.IS_PY3K:
-            self.assertWarns(RuntimeWarning, w.show)
-        else:
-            self.assertRaises(RuntimeWarning, w.show)
+        self.assertWarns(RuntimeWarning, w.show)
 
 
 if __name__ == '__main__':
diff --git a/sources/pyside2/tests/QtXml/qdomdocument_test.py b/sources/pyside2/tests/QtXml/qdomdocument_test.py
index 07319092c..37774288c 100644
--- a/sources/pyside2/tests/QtXml/qdomdocument_test.py
+++ b/sources/pyside2/tests/QtXml/qdomdocument_test.py
@@ -38,25 +38,25 @@ init_test_paths(False)
 
 from PySide2.QtCore import QByteArray
 from PySide2.QtXml import QDomDocument, QDomElement
-import py3kcompat as py3k
+
 
 class QDomDocumentTest(unittest.TestCase):
 
     def setUp(self):
         self.dom = QDomDocument()
 
-        self.goodXmlData = QByteArray(py3k.b('''
+        self.goodXmlData = QByteArray(bytes('''
         <typesystem package="PySide2.QtXml">
             <value-type name="QDomDocument"/>
             <value-type name="QDomElement"/>
         </typesystem>
-        '''))
+        ''', "UTF-8"))
 
-        self.badXmlData = QByteArray(py3k.b('''
+        self.badXmlData = QByteArray(bytes('''
         <typesystem package="PySide2.QtXml">
             <value-type name="QDomDocument">
         </typesystem>
-        '''))
+        ''', "UTF-8"))
 
     def tearDown(self):
         del self.dom
diff --git a/sources/pyside2/tests/QtXmlPatterns/import_test.py b/sources/pyside2/tests/QtXmlPatterns/import_test.py
index 09032909f..e60034e0d 100644
--- a/sources/pyside2/tests/QtXmlPatterns/import_test.py
+++ b/sources/pyside2/tests/QtXmlPatterns/import_test.py
@@ -39,7 +39,7 @@ init_test_paths(False)
 from PySide2.QtCore import *
 from PySide2.QtXmlPatterns import QXmlSchema
 from helper.usesqcoreapplication import UsesQCoreApplication
-import py3kcompat as py3k
+
 
 class QXmlPatternsTest(UsesQCoreApplication):
 
diff --git a/sources/pyside2/tests/pysidetest/modelview_test.py b/sources/pyside2/tests/pysidetest/modelview_test.py
index a4ae9dd40..e9d376801 100644
--- a/sources/pyside2/tests/pysidetest/modelview_test.py
+++ b/sources/pyside2/tests/pysidetest/modelview_test.py
@@ -36,7 +36,6 @@ sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 from init_paths import init_test_paths
 init_test_paths(True)
 
-import py3kcompat as py3k
 from testbinding import TestView
 from PySide2.QtCore import QAbstractListModel, QObject, QModelIndex
 
@@ -98,7 +97,7 @@ class ModelViewTest(unittest.TestCase):
         model = ListModelThatReturnsString()
         view = TestView(model)
         obj = view.getData()
-        self.assertEqual(type(obj), py3k.unicode)
+        self.assertEqual(type(obj), str)
         self.assertEqual(obj, 'string')
 
 if __name__ == '__main__':
diff --git a/sources/pyside2/tests/signals/signal_enum_test.py b/sources/pyside2/tests/signals/signal_enum_test.py
index 3a24b919d..d48aa10cf 100644
--- a/sources/pyside2/tests/signals/signal_enum_test.py
+++ b/sources/pyside2/tests/signals/signal_enum_test.py
@@ -26,6 +26,7 @@
 ##
 #############################################################################
 
+from enum import Enum
 import os
 import sys
 import unittest
@@ -36,47 +37,44 @@ from init_paths import init_test_paths
 init_test_paths(False)
 
 from PySide2.QtCore import QObject, Signal, Slot
-import py3kcompat as py3k
 
 
-if py3k.IS_PY3K:
-    from enum import Enum
+class Colors(Enum):
+    red = 1
+    green = 2
+    blue = 3
 
-    class Colors(Enum):
-        red = 1
-        green = 2
-        blue = 3
+class Obj(QObject):
+    enum_signal = Signal(Colors)
+    object_signal = Signal(object)
 
-    class Obj(QObject):
-        enum_signal = Signal(Colors)
-        object_signal = Signal(object)
+    def __init__(self, parent=None):
+        QObject.__init__(self, parent)
+        self.enum_signal.connect(self.get_result)
+        self.object_signal.connect(self.get_result)
+        self.value = -1
 
-        def __init__(self, parent=None):
-            QObject.__init__(self, parent)
-            self.enum_signal.connect(self.get_result)
-            self.object_signal.connect(self.get_result)
-            self.value = -1
+    @Slot()
+    def get_result(self, i):
+        self.value = i
 
-        @Slot()
-        def get_result(self, i):
-            self.value = i
 
+class SignalEnumTests(unittest.TestCase):
+    '''Test Signal with enum.Enum'''
 
-    class SignalEnumTests(unittest.TestCase):
-        '''Test Signal with enum.Enum'''
+    def testSignal(self):
+        o = Obj()
+        # Default value
+        self.assertEqual(o.value, -1)
 
-        def testSignal(self):
-            o = Obj()
-            # Default value
-            self.assertEqual(o.value, -1)
+        # Enum Signal
+        o.enum_signal.emit(Colors.green)
+        self.assertEqual(o.value, Colors.green)
 
-            # Enum Signal
-            o.enum_signal.emit(Colors.green)
-            self.assertEqual(o.value, Colors.green)
+        # object Signal
+        o.object_signal.emit(Colors.red)
+        self.assertEqual(o.value, Colors.red)
 
-            # object Signal
-            o.object_signal.emit(Colors.red)
-            self.assertEqual(o.value, Colors.red)
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/sources/pyside2/tests/util/httpd.py b/sources/pyside2/tests/util/httpd.py
index 41ac126fb..82bec337d 100644
--- a/sources/pyside2/tests/util/httpd.py
+++ b/sources/pyside2/tests/util/httpd.py
@@ -26,23 +26,17 @@
 ##
 #############################################################################
 
+import http.server as BaseHTTPServer
 import os
 import random
 import select
 import sys
+import socketserver as SocketServer
 import tempfile
 import threading
 
 sys.path.append(os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "util"))
 
-import py3kcompat as py3k
-
-if py3k.IS_PY3K:
-    import socketserver as SocketServer
-    import http.server as BaseHTTPServer
-else:
-    import SocketServer
-    import BaseHTTPServer
 
 class TestHandler(BaseHTTPServer.BaseHTTPRequestHandler):
     DATA = "PySide Server"
diff --git a/sources/pyside2/tests/util/py3kcompat.py b/sources/pyside2/tests/util/py3kcompat.py
deleted file mode 100644
index bd90973ec..000000000
--- a/sources/pyside2/tests/util/py3kcompat.py
+++ /dev/null
@@ -1,82 +0,0 @@
-# -*- coding: utf-8 -*-
-
-#############################################################################
-##
-## Copyright (C) 2020 The Qt Company Ltd.
-## Contact: https://www.qt.io/licensing/
-##
-## This file is part of the test suite of Qt for Python.
-##
-## $QT_BEGIN_LICENSE:GPL-EXCEPT$
-## Commercial License Usage
-## Licensees holding valid commercial Qt licenses may use this file in
-## accordance with the commercial license agreement provided with the
-## Software or, alternatively, in accordance with the terms contained in
-## a written agreement between you and The Qt Company. For licensing terms
-## and conditions see https://www.qt.io/terms-conditions. For further
-## information use the contact form at https://www.qt.io/contact-us.
-##
-## GNU General Public License Usage
-## Alternatively, this file may be used under the terms of the GNU
-## General Public License version 3 as published by the Free Software
-## Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
-## included in the packaging of this file. Please review the following
-## information to ensure the GNU General Public License requirements will
-## be met: https://www.gnu.org/licenses/gpl-3.0.html.
-##
-## $QT_END_LICENSE$
-##
-#############################################################################
-
-# Copy of ../../../shiboken2/tests/py3kcompat.py
-
-import sys
-
-IS_PY3K = sys.version_info[0] == 3
-
-if IS_PY3K:
-    def b(s):
-        if type(s) == bytes:
-            return s
-        return bytes(s, "UTF8")
-
-    def buffer_(s):
-        if s == None:
-            return None
-        elif type(s) == str:
-            return bytes(s, "UTF8")
-        elif type(s) == bytes:
-            return s
-        else:
-            memoryview(s)
-
-    def l(n):
-        return n
-
-    def unicode_(s):
-        return s
-
-    unicode = str
-    unichr = chr
-    long = int
-    unichr = chr
-    buffer = buffer_
-else:
-    def b(s):
-        return s
-
-    def l(n):
-        return long(n)
-
-    def unicode_(s):
-        if type(s) == str:
-            import codecs
-            c = codecs.lookup('utf-8')
-            s2 = c.decode(s, 'ignore')
-            return s2[0]
-        return u'%s' % s
-
-    unicode = unicode
-    unichr = unichr
-    long = long
-    buffer = buffer