PyEnum: Prepare Enum tests for both old and new enums

These tests are now completely identical to the old tests
and have an adapted Python Enum version if suitable.
Both versions can be selected once at runtime.

Having both test versions available as a runtime option
is a nice feature that really helps understanding the
consequences of the PyEnum move.

[ChangeLog][PySide6] The QEnum tests are enabled for both the
old Qt Enums and the new Python Enums.

Change-Id: I78a7473f4a86f8d2115acc56e4ed11cf135eb000
Task-number: PYSIDE-1735
Reviewed-by: Christian Tismer <tismer@stackless.com>
(cherry picked from commit 4362ded78ae459265c1e6b7cf562d5cdad382003)

13 files changed, 99 insertions, 42 deletions

diff --git a/sources/pyside6/tests/QtCore/bug_462.py b/sources/pyside6/tests/QtCore/bug_462.py
index 1d16e2ab9..4089b449a 100644
--- a/sources/pyside6/tests/QtCore/bug_462.py
+++ b/sources/pyside6/tests/QtCore/bug_462.py
@@ -41,7 +41,7 @@ from PySide6.QtCore import QObject, QCoreApplication, QEvent, QThread
 class MyEvent(QEvent):
     def __init__(self, i):
         print("TYPE:", type(QEvent.User))
-        super().__init__(QEvent.Type(QEvent.User + 100))
+        super().__init__(QEvent.Type(QEvent.User + (0 if sys.pyside63_option_python_enum else 100)))
         self.i = i
 
 
diff --git a/sources/pyside6/tests/QtCore/bug_826.py b/sources/pyside6/tests/QtCore/bug_826.py
index 3b1fb3714..08fdbc02e 100644
--- a/sources/pyside6/tests/QtCore/bug_826.py
+++ b/sources/pyside6/tests/QtCore/bug_826.py
@@ -43,7 +43,7 @@ TEST_EVENT_TYPE = QEvent.Type(QEvent.registerEventType())
 
 
 class TestEvent(QEvent):
-    TestEventType = QEvent.Type(QEvent.registerEventType())
+    TestEventType = QEvent.Type(TEST_EVENT_TYPE)
 
     def __init__(self, rand=0):
         super().__init__(TestEvent.TestEventType)
@@ -58,6 +58,7 @@ class TestEnums(unittest.TestCase):
         self.assertTrue(QEvent.User <= TestEvent.TestEventType <= QEvent.MaxUser)
         self.assertTrue(QEvent.User <= TEST_EVENT_TYPE <= QEvent.MaxUser)
 
+    @unittest.skipIf(sys.pyside63_option_python_enum, "makes no sense for tested Python enums")
     def testUserTypesRepr(self):
         self.assertEqual(eval(repr(TestEvent.TestEventType)), TestEvent.TestEventType)
         self.assertEqual(eval(repr(TEST_EVENT_TYPE)), TEST_EVENT_TYPE)
diff --git a/sources/pyside6/tests/QtCore/qcbor_test.py b/sources/pyside6/tests/QtCore/qcbor_test.py
index f71257ae7..5b005c7ef 100644
--- a/sources/pyside6/tests/QtCore/qcbor_test.py
+++ b/sources/pyside6/tests/QtCore/qcbor_test.py
@@ -82,6 +82,9 @@ class TestCbor(unittest.TestCase):
         value = QCborValue('hello')
         self.assertTrue(value.isString())
         self.assertEqual(value.toString(), 'hello')
+        if sys.pyside63_option_python_enum:
+            # PYSIDE-1735: Undefined enums are not possible
+            return
         tag = value.tag(QCborTag(32))
         self.assertEqual(int(tag), 32)
 
diff --git a/sources/pyside6/tests/QtCore/qenum_test.py b/sources/pyside6/tests/QtCore/qenum_test.py
index 1f32d957f..0307e3dbc 100644
--- a/sources/pyside6/tests/QtCore/qenum_test.py
+++ b/sources/pyside6/tests/QtCore/qenum_test.py
@@ -59,6 +59,7 @@ class TestEnum(unittest.TestCase):
     def testToIntInFunction(self):
         self.assertEqual(str(int(QIODevice.WriteOnly)), "2")
 
+    @unittest.skipIf(sys.pyside63_option_python_enum, "makes no sense for tested Python enums")
     def testOperations(self):
         k = Qt.Key.Key_1
 
@@ -77,6 +78,7 @@ class TestEnum(unittest.TestCase):
         with self.assertRaises(TypeError):
             a = k * 2.0
 
+    @unittest.skipIf(sys.pyside63_option_python_enum, "inheritance forbidden for Python enums")
     def testInherit(self):
         class A(Qt.Key):
             pass
diff --git a/sources/pyside6/tests/QtCore/qflags_test.py b/sources/pyside6/tests/QtCore/qflags_test.py
index bde6abde1..3f13b0db1 100644
--- a/sources/pyside6/tests/QtCore/qflags_test.py
+++ b/sources/pyside6/tests/QtCore/qflags_test.py
@@ -67,19 +67,22 @@ class QFlagOperatorTest(unittest.TestCase):
 
     def testInvert(self):
         '''QFlags ~ (invert) operator'''
-        self.assertEqual(type(~QIODevice.ReadOnly), QIODevice.OpenMode)
+        self.assertEqual(type(~QIODevice.ReadOnly), QIODevice.OpenModeFlag
+            if sys.pyside63_option_python_enum else QIODevice.OpenMode)
 
     def testOr(self):
         '''QFlags | (or) operator'''
-        self.assertEqual(type(QIODevice.ReadOnly | QIODevice.WriteOnly), QIODevice.OpenMode)
+        self.assertEqual(type(QIODevice.ReadOnly | QIODevice.WriteOnly), QIODevice.OpenModeFlag
+            if sys.pyside63_option_python_enum else QIODevice.OpenMode)
 
     def testAnd(self):
         '''QFlags & (and) operator'''
-        self.assertEqual(type(QIODevice.ReadOnly & QIODevice.WriteOnly), QIODevice.OpenMode)
+        self.assertEqual(type(QIODevice.ReadOnly & QIODevice.WriteOnly), QIODevice.OpenModeFlag
+            if sys.pyside63_option_python_enum else QIODevice.OpenMode)
 
     def testIOr(self):
         '''QFlags |= (ior) operator'''
-        flag = Qt.WindowFlags()
+        flag = Qt.WindowType(1) if sys.pyside63_option_python_enum else Qt.WindowFlags()
         self.assertTrue(Qt.Widget == 0)
         self.assertFalse(flag & Qt.Widget)
         result = flag & Qt.Widget
@@ -89,7 +92,8 @@ class QFlagOperatorTest(unittest.TestCase):
 
     def testInvertOr(self):
         '''QFlags ~ (invert) operator over the result of an | (or) operator'''
-        self.assertEqual(type(~(Qt.ItemIsSelectable | Qt.ItemIsEditable)), Qt.ItemFlags)
+        self.assertEqual(type(~(Qt.ItemIsSelectable | Qt.ItemIsEditable)), Qt.ItemFlag
+            if sys.pyside63_option_python_enum else Qt.ItemFlags)
 
     def testEqual(self):
         '''QFlags == operator'''
@@ -98,7 +102,8 @@ class QFlagOperatorTest(unittest.TestCase):
         flag_type = (flags & Qt.WindowType_Mask)
         self.assertEqual(flag_type, Qt.Window)
 
-        self.assertEqual(Qt.KeyboardModifiers(Qt.ControlModifier), Qt.ControlModifier)
+        self.assertEqual((Qt.KeyboardModifier if sys.pyside63_option_python_enum else
+            Qt.KeyboardModifiers)(Qt.ControlModifier), Qt.ControlModifier)
 
     def testOperatorBetweenFlags(self):
         '''QFlags & QFlags'''
@@ -116,7 +121,8 @@ class QFlagsOnQVariant(unittest.TestCase):
     def testQFlagsOnQVariant(self):
         o = QObject()
         o.setProperty("foo", QIODevice.ReadOnly | QIODevice.WriteOnly)
-        self.assertEqual(type(o.property("foo")), QIODevice.OpenMode)
+        self.assertEqual(type(o.property("foo")), QIODevice.OpenModeFlag
+            if sys.pyside63_option_python_enum else QIODevice.OpenMode)
 
 
 class QFlagsWrongType(unittest.TestCase):
diff --git a/sources/pyside6/tests/QtGui/bug_617.py b/sources/pyside6/tests/QtGui/bug_617.py
index d917745be..36ad2b8ed 100644
--- a/sources/pyside6/tests/QtGui/bug_617.py
+++ b/sources/pyside6/tests/QtGui/bug_617.py
@@ -41,7 +41,12 @@ from PySide6.QtGui import QColor
 
 class MyEvent(QEvent):
     def __init__(self):
-        QEvent.__init__(self, QEvent.Type(999))
+        if sys.pyside63_option_python_enum:
+            # PYSIDE-1735: Python Enum: We cannot assign arbitrary numbers.
+            #              They must exist as constants in the type.
+            QEvent.__init__(self, QEvent.Type(1000))
+        else:
+            QEvent.__init__(self, QEvent.Type(999))
 
 
 class Bug617(unittest.TestCase):
@@ -52,7 +57,8 @@ class Bug617(unittest.TestCase):
 
     def testOutOfBounds(self):
         e = MyEvent()
-        self.assertEqual(repr(e.type()), 'PySide6.QtCore.QEvent.Type(999)')
+        self.assertEqual(repr(e.type()), "<Type.User: 1000>"
+            if sys.pyside63_option_python_enum else "PySide6.QtCore.QEvent.Type(999)")
 
 
 if __name__ == "__main__":
diff --git a/sources/pyside6/tests/QtWidgets/qformlayout_test.py b/sources/pyside6/tests/QtWidgets/qformlayout_test.py
index 1bb89d61c..55348daaa 100644
--- a/sources/pyside6/tests/QtWidgets/qformlayout_test.py
+++ b/sources/pyside6/tests/QtWidgets/qformlayout_test.py
@@ -44,10 +44,12 @@ class QFormLayoutTest(UsesQApplication):
 
     def testGetItemPosition(self):
         formlayout = QFormLayout()
-        row, role = formlayout.getItemPosition(0)
-        self.assertTrue(isinstance(row, int))
-        self.assertTrue(isinstance(role, QFormLayout.ItemRole))
-        self.assertEqual(row, -1)
+        if not sys.pyside63_option_python_enum:
+            # PYSIDE-1735: This gives random values if no row exists.
+            row, role = formlayout.getItemPosition(0)
+            self.assertTrue(isinstance(row, int))
+            self.assertTrue(isinstance(role, QFormLayout.ItemRole))
+            self.assertEqual(row, -1)
 
         widget = QWidget()
         formlayout.addRow(widget)
@@ -60,10 +62,12 @@ class QFormLayoutTest(UsesQApplication):
     def testGetWidgetPosition(self):
         formlayout = QFormLayout()
         widget = QWidget()
-        row, role = formlayout.getWidgetPosition(widget)
-        self.assertTrue(isinstance(row, int))
-        self.assertTrue(isinstance(role, QFormLayout.ItemRole))
-        self.assertEqual(row, -1)
+        if not sys.pyside63_option_python_enum:
+            # PYSIDE-1735: This gives random values if no row exists.
+            row, role = formlayout.getWidgetPosition(widget)
+            self.assertTrue(isinstance(row, int))
+            self.assertTrue(isinstance(role, QFormLayout.ItemRole))
+            self.assertEqual(row, -1)
 
         formlayout.addRow(widget)
         row, role = formlayout.getWidgetPosition(widget)
@@ -75,10 +79,12 @@ class QFormLayoutTest(UsesQApplication):
     def testGetLayoutPosition(self):
         formlayout = QFormLayout()
         layout = QFormLayout()
-        row, role = formlayout.getLayoutPosition(layout)
-        self.assertTrue(isinstance(row, int))
-        self.assertTrue(isinstance(role, QFormLayout.ItemRole))
-        self.assertEqual(row, -1)
+        if not sys.pyside63_option_python_enum:
+            # PYSIDE-1735: This gives random values if no row exists.
+            row, role = formlayout.getLayoutPosition(layout)
+            self.assertTrue(isinstance(row, int))
+            self.assertTrue(isinstance(role, QFormLayout.ItemRole))
+            self.assertEqual(row, -1)
 
         formlayout.addRow(layout)
         row, role = formlayout.getLayoutPosition(layout)
diff --git a/sources/pyside6/tests/QtWidgets/qlabel_test.py b/sources/pyside6/tests/QtWidgets/qlabel_test.py
index 58e5ce544..dc1ed8a10 100644
--- a/sources/pyside6/tests/QtWidgets/qlabel_test.py
+++ b/sources/pyside6/tests/QtWidgets/qlabel_test.py
@@ -94,7 +94,8 @@ class QLabelTest(UsesQApplication):
     # Test for PYSIDE-1673, QObject.property() returning a QFlags<> property.
     def testQObjectProperty(self):
         a = self.label.property("alignment")
-        self.assertEqual(type(a), Qt.Alignment)
+        self.assertEqual(type(a), Qt.AlignmentFlag if sys.pyside63_option_python_enum
+                                                   else Qt.Alignment)
         print("alignment=", a)
 
 
diff --git a/sources/pyside6/tests/pysidetest/new_inherited_functions_test.py b/sources/pyside6/tests/pysidetest/new_inherited_functions_test.py
index 210ac9178..1d612da5b 100644
--- a/sources/pyside6/tests/pysidetest/new_inherited_functions_test.py
+++ b/sources/pyside6/tests/pysidetest/new_inherited_functions_test.py
@@ -126,10 +126,15 @@ class MainTest(unittest.TestCase):
         qint64 = 42
         tfarg = os.path.join(PySide6.QtCore.QDir.tempPath(), "XXXXXX.tmp")
         findStr = 'bla'
-        orientation = PySide6.QtCore.Qt.Orientation()
-        openMode = PySide6.QtCore.QIODevice.OpenMode(PySide6.QtCore.QIODevice.ReadOnly)
+        if sys.pyside63_option_python_enum:
+            orientation = PySide6.QtCore.Qt.Orientation(0)
+            openMode = PySide6.QtCore.QIODevice.OpenModeFlag(PySide6.QtCore.QIODevice.ReadOnly)
+            transformationMode = PySide6.QtCore.Qt.TransformationMode(0)
+        else:
+            orientation = PySide6.QtCore.Qt.Orientation()
+            openMode = PySide6.QtCore.QIODevice.OpenMode(PySide6.QtCore.QIODevice.ReadOnly)
+            transformationMode = PySide6.QtCore.Qt.TransformationMode()
         qModelIndex = PySide6.QtCore.QModelIndex()
-        transformationMode = PySide6.QtCore.Qt.TransformationMode()
         qObject = PySide6.QtCore.QObject()
         qPoint = PySide6.QtCore.QPoint()
         try:
@@ -144,7 +149,8 @@ class MainTest(unittest.TestCase):
             pass
         try:
             PySide6.QtWidgets
-            direction = PySide6.QtWidgets.QBoxLayout.Direction()
+            direction = (PySide6.QtWidgets.QBoxLayout.Direction(0)
+                if sys.pyside63_option_python_enum else PySide6.QtWidgets.QBoxLayout.Direction())
             qWidget = PySide6.QtWidgets.QWidget()
             qStyleOptionFrame = PySide6.QtWidgets.QStyleOptionFrame()
             qAction = PySide6.QtGui.QAction(qObject)
diff --git a/sources/shiboken6/shibokenmodule/files.dir/shibokensupport/signature/lib/pyi_generator.py b/sources/shiboken6/shibokenmodule/files.dir/shibokensupport/signature/lib/pyi_generator.py
index aed6a6f46..fb8f347c9 100644
--- a/sources/shiboken6/shibokenmodule/files.dir/shibokensupport/signature/lib/pyi_generator.py
+++ b/sources/shiboken6/shibokenmodule/files.dir/shibokensupport/signature/lib/pyi_generator.py
@@ -196,7 +196,7 @@ def find_imports(text):
 FROM_IMPORTS = [
     (None, ["builtins"]),
     (None, ["os"]),
-    ("enum", ["Enum"]),
+    (None, ["enum"]),
     ("typing", typing.__all__),
     ("PySide6.QtCore", ["PyClassProperty"]),
     ("shiboken6", ["Shiboken"]),
diff --git a/sources/shiboken6/tests/otherbinding/signature_test.py b/sources/shiboken6/tests/otherbinding/signature_test.py
index 3160ce5fa..81fc8cdc0 100644
--- a/sources/shiboken6/tests/otherbinding/signature_test.py
+++ b/sources/shiboken6/tests/otherbinding/signature_test.py
@@ -51,11 +51,14 @@ from shibokensupport.signature import get_signature
 
 class SignatureTest(unittest.TestCase):
 
-    # Check if the argument of 'OtherObjectType::enumAsInt(SampleNamespace::SomeClass::PublicScopedEnum value)'
+    # Check if the argument of
+    # 'OtherObjectType::enumAsInt(SampleNamespace::SomeClass::PublicScopedEnum value)'
     # has the correct representation
     def testNamespaceFromOtherModule(self):
-        argType = get_signature(OtherObjectType.enumAsInt).parameters['value'].annotation
-        self.assertEqual(objectFullname(argType), 'sample.SampleNamespace.SomeClass.PublicScopedEnum')
+        argType = get_signature(OtherObjectType.enumAsInt).parameters["value"].annotation
+        self.assertEqual(objectFullname(argType),
+            "sample.SampleNamespace.SomeClass.PublicScopedEnum")
+
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/sources/shiboken6/tests/samplebinding/enum_test.py b/sources/shiboken6/tests/samplebinding/enum_test.py
index 66d7daf5b..e4bfb811d 100644
--- a/sources/shiboken6/tests/samplebinding/enum_test.py
+++ b/sources/shiboken6/tests/samplebinding/enum_test.py
@@ -53,6 +53,7 @@ def createTempFile():
 class EnumTest(unittest.TestCase):
     '''Test case for Python representation of C++ enums.'''
 
+    @unittest.skipIf(sys.pyside63_option_python_enum, "test not suitable for Python enum")
     def testEnumRepr(self):
         enum = SampleNamespace.Option(1)
         self.assertEqual(eval(repr(enum)), enum)
@@ -66,7 +67,8 @@ class EnumTest(unittest.TestCase):
 
     def testEnumValuesInsideEnum(self):
         '''Enum values should be accessible inside the enum as well as outside.'''
-        for value_name in SampleNamespace.Option.values:
+        for value_name in (SampleNamespace.Option.__members__ if sys.pyside63_option_python_enum
+                      else SampleNamespace.Option.values):
             enum_item1 = getattr(SampleNamespace.Option, value_name)
             enum_item2 = getattr(SampleNamespace, value_name)
             self.assertEqual(enum_item1, enum_item2)
@@ -79,11 +81,13 @@ class EnumTest(unittest.TestCase):
         '''Tries to build the proper enum using an integer.'''
         SampleNamespace.getNumber(SampleNamespace.Option(1))
 
+    @unittest.skipIf(sys.pyside63_option_python_enum, "test not suitable for Python enum")
     def testBuildingEnumWithDefaultValue(self):
         '''Enum constructor with default value'''
         enum = SampleNamespace.Option()
         self.assertEqual(enum, SampleNamespace.None_)
 
+    @unittest.skipIf(sys.pyside63_option_python_enum, "test not suitable for Python enum")
     def testEnumConversionToAndFromPython(self):
         '''Conversion of enum objects from Python to C++ back again.'''
         enumout = SampleNamespace.enumInEnumOut(SampleNamespace.TwoIn)
@@ -96,7 +100,7 @@ class EnumTest(unittest.TestCase):
 
     def testEnumConstructorWithNonNumberParameter(self):
         '''Calling the constructor of non-extensible enum with a string.'''
-        self.assertRaises(TypeError, SampleNamespace.InValue, '1')
+        self.assertRaises((TypeError, ValueError), SampleNamespace.InValue, '1')
 
     def testEnumItemAsDefaultValueToIntArgument(self):
         '''Calls function with an enum item as default value to an int argument.'''
@@ -127,6 +131,7 @@ class EnumTest(unittest.TestCase):
         event.setEventTypeByConstRef(Event.SOME_EVENT)
         self.assertEqual(event.eventType(), Event.SOME_EVENT)
 
+    @unittest.skipIf(sys.pyside63_option_python_enum, "test not suitable for Python enum")
     def testEnumTpPrintImplementation(self):
         '''Without SbkEnum.tp_print 'print' returns the enum represented as an int.'''
         tmpfile = createTempFile()
@@ -142,12 +147,14 @@ class EnumTest(unittest.TestCase):
         self.assertEqual(SampleNamespace.enumArgumentWithDefaultValue(), SampleNamespace.UnixTime)
         self.assertEqual(SampleNamespace.enumArgumentWithDefaultValue(SampleNamespace.RandomNumber), SampleNamespace.RandomNumber)
 
+    @unittest.skipIf(sys.pyside63_option_python_enum, "test not suitable for Python enum")
     def testSignature(self):
         enum = SampleNamespace.Option(1)
         types = type(enum).mro()
         klass = types[0]
         base = types[1]
         # The class has an empty signature.
+
         self.assertEqual(klass.__signature__, None)
         # The base class must be Enum
         self.assertNotEqual(base.__signature__, None)
@@ -158,18 +165,22 @@ class EnumTest(unittest.TestCase):
 
 class MyEvent(Event):
     def __init__(self):
-        Event.__init__(self, Event.EventType(999))
+        Event.__init__(self, Event.EventType(3 if sys.pyside63_option_python_enum else 999))
+
 
 class OutOfBoundsTest(unittest.TestCase):
     def testValue(self):
         e = MyEvent()
-        self.assertEqual(repr(e.eventType()), 'sample.Event.EventType(999)')
+        self.assertEqual(repr(e.eventType()), "<EventType.ANY_EVENT: 3>"
+            if sys.pyside63_option_python_enum else 'sample.Event.EventType(999)')
 
+    @unittest.skipIf(sys.pyside63_option_python_enum, "test not suitable for Python enum")
     def testNoneName(self):
         e = MyEvent()
         t = e.eventType()
         self.assertEqual(t.name, None)
 
+
 class EnumOverloadTest(unittest.TestCase):
     '''Test case for overloads involving enums'''
 
@@ -180,6 +191,7 @@ class EnumOverloadTest(unittest.TestCase):
         self.assertEqual(o.callWithEnum('', Event.ANY_EVENT, 9), 81)
         self.assertEqual(o.callWithEnum('', 9), 9)
 
+
 class EnumOperators(unittest.TestCase):
     '''Test case for operations on enums'''
 
diff --git a/sources/shiboken6/tests/samplebinding/namespace_test.py b/sources/shiboken6/tests/samplebinding/namespace_test.py
index ca6d2bf39..2bd5f8f4e 100644
--- a/sources/shiboken6/tests/samplebinding/namespace_test.py
+++ b/sources/shiboken6/tests/samplebinding/namespace_test.py
@@ -59,12 +59,20 @@ class TestVariablesUnderNamespace(unittest.TestCase):
 
 class TestClassesUnderNamespace(unittest.TestCase):
     def testIt(self):
-        c1 = SampleNamespace.SomeClass()
-        e1 = SampleNamespace.SomeClass.ProtectedEnum()
-        c2 = SampleNamespace.SomeClass.SomeInnerClass()
-        e2 = SampleNamespace.SomeClass.SomeInnerClass.ProtectedEnum()
-        c3 = SampleNamespace.SomeClass.SomeInnerClass.OkThisIsRecursiveEnough()
-        e3 = SampleNamespace.SomeClass.SomeInnerClass.OkThisIsRecursiveEnough.NiceEnum()
+        if sys.pyside63_option_python_enum:
+            c1 = SampleNamespace.SomeClass()
+            e1 = SampleNamespace.SomeClass.ProtectedEnum(0)
+            c2 = SampleNamespace.SomeClass.SomeInnerClass()
+            e2 = SampleNamespace.SomeClass.SomeInnerClass.ProtectedEnum(0)
+            c3 = SampleNamespace.SomeClass.SomeInnerClass.OkThisIsRecursiveEnough()
+            e3 = SampleNamespace.SomeClass.SomeInnerClass.OkThisIsRecursiveEnough.NiceEnum(0)
+        else:
+            c1 = SampleNamespace.SomeClass()
+            e1 = SampleNamespace.SomeClass.ProtectedEnum()
+            c2 = SampleNamespace.SomeClass.SomeInnerClass()
+            e2 = SampleNamespace.SomeClass.SomeInnerClass.ProtectedEnum()
+            c3 = SampleNamespace.SomeClass.SomeInnerClass.OkThisIsRecursiveEnough()
+            e3 = SampleNamespace.SomeClass.SomeInnerClass.OkThisIsRecursiveEnough.NiceEnum()
 
     def testFunctionAddedOnNamespace(self):
         res = SampleNamespace.ImInsideANamespace(2, 2)
@@ -74,12 +82,15 @@ class TestClassesUnderNamespace(unittest.TestCase):
         self.assertEqual(str(SampleNamespace.SomeClass),
             "<class 'sample.SampleNamespace.SomeClass'>")
         self.assertEqual(str(SampleNamespace.SomeClass.ProtectedEnum),
+            "<enum 'ProtectedEnum'>" if sys.pyside63_option_python_enum else
             "<class 'sample.SampleNamespace.SomeClass.ProtectedEnum'>")
         self.assertEqual(str(SampleNamespace.SomeClass.SomeInnerClass.ProtectedEnum),
+            "<enum 'ProtectedEnum'>" if sys.pyside63_option_python_enum else
             "<class 'sample.SampleNamespace.SomeClass.SomeInnerClass.ProtectedEnum'>")
         self.assertEqual(str(SampleNamespace.SomeClass.SomeInnerClass.OkThisIsRecursiveEnough),
             "<class 'sample.SampleNamespace.SomeClass.SomeInnerClass.OkThisIsRecursiveEnough'>")
         self.assertEqual(str(SampleNamespace.SomeClass.SomeInnerClass.OkThisIsRecursiveEnough.NiceEnum),
+            "<enum 'NiceEnum'>" if sys.pyside63_option_python_enum else
             "<class 'sample.SampleNamespace.SomeClass.SomeInnerClass.OkThisIsRecursiveEnough.NiceEnum'>")
 
         # Test if enum inside of class is correct represented