PyEnum: Remove the now unreachable test cases for old enums

Task-number: PYSIDE-1735
Change-Id: I51e68c50872f1d1254218ae7556ba607f73c4ea9
Reviewed-by: Friedemann Kleint <Friedemann.Kleint@qt.io>
Reviewed-by: Shyamnath Premnadh <Shyamnath.Premnadh@qt.io>

6 files changed, 6 insertions, 117 deletions

diff --git a/sources/shiboken6/tests/samplebinding/derived_test.py b/sources/shiboken6/tests/samplebinding/derived_test.py
index 62a8d6337..a92ccd311 100644
--- a/sources/shiboken6/tests/samplebinding/derived_test.py
+++ b/sources/shiboken6/tests/samplebinding/derived_test.py
@@ -40,23 +40,6 @@ class DerivedTest(unittest.TestCase):
                                  'id_', 'pureVirtual', 'unpureVirtual'])
         self.assertTrue(inherited_methods.issubset(dir(Derived)))
 
-    @unittest.skipIf(sys.pyside6_option_python_enum, "Makes no sense with strict Enums")
-    def testOverloadedMethodCall(self):
-        '''Test if the correct overloaded method is being called.'''
-        derived = Derived()
-
-        result = derived.overloaded(1, 2)
-        self.assertEqual(type(result), OverloadedFuncEnum)
-        self.assertEqual(result, sample.OverloadedFunc_ii)
-
-        result = derived.overloaded(3)
-        self.assertEqual(type(result), OverloadedFuncEnum)
-        self.assertEqual(result, sample.OverloadedFunc_ii)
-
-        result = derived.overloaded(4.4)
-        self.assertEqual(type(result), OverloadedFuncEnum)
-        self.assertEqual(result, sample.OverloadedFunc_d)
-
     def testOtherOverloadedMethodCall(self):
         '''Another test to check overloaded method calling, just to double check.'''
         derived = Derived()
@@ -74,8 +57,6 @@ class DerivedTest(unittest.TestCase):
         derived = Derived()
         result = derived.overloaded(1.1, 2.2)
         self.assertEqual(type(result), OverloadedFuncEnum)
-        if not sys.pyside6_option_python_enum:
-            self.assertEqual(result, sample.OverloadedFunc_ii)
 
     def testOverloadedMethodCallWithWrongNumberOfArguments(self):
         '''Test if a call to an overloaded method with the wrong number of arguments raises an exception.'''
diff --git a/sources/shiboken6/tests/samplebinding/enum_test.py b/sources/shiboken6/tests/samplebinding/enum_test.py
index 48748aba3..137f325fb 100644
--- a/sources/shiboken6/tests/samplebinding/enum_test.py
+++ b/sources/shiboken6/tests/samplebinding/enum_test.py
@@ -29,22 +29,13 @@ def createTempFile():
 class EnumTest(unittest.TestCase):
     '''Test case for Python representation of C++ enums.'''
 
-    @unittest.skipIf(sys.pyside6_option_python_enum, "test not suitable for Python enum")
-    def testEnumRepr(self):
-        enum = SampleNamespace.Option(1)
-        self.assertEqual(eval(repr(enum)), enum)
-
-        enum = SampleNamespace.Option(999)
-        self.assertEqual(eval(repr(enum)), enum)
-
     def testHashability(self):
         self.assertEqual(hash(SampleNamespace.TwoIn), hash(SampleNamespace.TwoOut))
         self.assertNotEqual(hash(SampleNamespace.TwoIn), hash(SampleNamespace.OneIn))
 
     def testEnumValuesInsideEnum(self):
         '''Enum values should be accessible inside the enum as well as outside.'''
-        for value_name in (SampleNamespace.Option.__members__ if sys.pyside6_option_python_enum
-                      else SampleNamespace.Option.values):
+        for value_name in SampleNamespace.Option.__members__:
             enum_item1 = getattr(SampleNamespace.Option, value_name)
             enum_item2 = getattr(SampleNamespace, value_name)
             self.assertEqual(enum_item1, enum_item2)
@@ -107,54 +98,21 @@ class EnumTest(unittest.TestCase):
         event.setEventTypeByConstPtr(Event.BASIC_EVENT)
         self.assertEqual(event.eventType(), Event.BASIC_EVENT)
 
-    @unittest.skipIf(sys.pyside6_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()
-        print(Event.ANY_EVENT, file=tmpfile)
-        tmpfile.seek(0)
-        text = tmpfile.read().strip()
-        tmpfile.close()
-        self.assertEqual(text, str(Event.ANY_EVENT))
-        self.assertEqual(text, repr(Event.ANY_EVENT))
-
     def testEnumArgumentWithDefaultValue(self):
         '''Option enumArgumentWithDefaultValue(Option opt = UnixTime);'''
         self.assertEqual(SampleNamespace.enumArgumentWithDefaultValue(), SampleNamespace.UnixTime)
         self.assertEqual(SampleNamespace.enumArgumentWithDefaultValue(SampleNamespace.RandomNumber), SampleNamespace.RandomNumber)
 
-    @unittest.skipIf(sys.pyside6_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(get_signature(klass), None)
-        # The base class must be Enum
-        self.assertNotEqual(get_signature(base), None)
-        # It contains an int annotation.
-        param = get_signature(base).parameters["itemValue"]
-        self.assertEqual(param.annotation, int)
-
 
 class MyEvent(Event):
     def __init__(self):
-        Event.__init__(self, Event.EventType(3 if sys.pyside6_option_python_enum else 999))
+        Event.__init__(self, Event.EventType(3))
 
 
 class OutOfBoundsTest(unittest.TestCase):
     def testValue(self):
         e = MyEvent()
-        self.assertEqual(repr(e.eventType()), "<EventType.ANY_EVENT: 3>"
-            if sys.pyside6_option_python_enum else 'sample.Event.EventType(999)')
-
-    @unittest.skipIf(sys.pyside6_option_python_enum, "test not suitable for Python enum")
-    def testNoneName(self):
-        e = MyEvent()
-        t = e.eventType()
-        self.assertEqual(t.name, None)
+        self.assertEqual(repr(e.eventType()), "<EventType.ANY_EVENT: 3>")
 
 
 class EnumOverloadTest(unittest.TestCase):
diff --git a/sources/shiboken6/tests/samplebinding/enumfromremovednamespace_test.py b/sources/shiboken6/tests/samplebinding/enumfromremovednamespace_test.py
index b7c21bbae..004caac70 100644
--- a/sources/shiboken6/tests/samplebinding/enumfromremovednamespace_test.py
+++ b/sources/shiboken6/tests/samplebinding/enumfromremovednamespace_test.py
@@ -21,15 +21,6 @@ from shibokensupport.signature import get_signature
 
 class TestEnumFromRemovedNamespace(unittest.TestCase):
 
-    @unittest.skipIf(sys.pyside6_option_python_enum, "Makes no sense with strict Enums")
-    def testEnumPromotedToGlobal(self):
-        sample.RemovedNamespace1_Enum
-        self.assertEqual(sample.RemovedNamespace1_Enum_Value0, 0)
-        self.assertEqual(sample.RemovedNamespace1_Enum_Value1, 1)
-        sample.RemovedNamespace1_AnonymousEnum_Value0
-        sample.RemovedNamespace2_Enum
-        sample.RemovedNamespace2_Enum_Value0
-
     def testNames(self):
         # Test if invisible namespace does not appear on type name
         self.assertEqual(objectFullname(sample.RemovedNamespace1_Enum),
diff --git a/sources/shiboken6/tests/samplebinding/modifications_test.py b/sources/shiboken6/tests/samplebinding/modifications_test.py
index 8c1441c2d..008221527 100644
--- a/sources/shiboken6/tests/samplebinding/modifications_test.py
+++ b/sources/shiboken6/tests/samplebinding/modifications_test.py
@@ -41,18 +41,6 @@ class ModificationsTest(unittest.TestCase):
         # PYSIDE-535: Need to collect garbage in PyPy to trigger deletion
         gc.collect()
 
-    @unittest.skipIf(sys.pyside6_option_python_enum, "Makes no sense with strict Enums")
-    def testClassMembersAvailability(self):
-        '''Test if Modified class really have the expected members.'''
-        expected_members = set(['OverloadedModFunc', 'OverloadedNone',
-                                'Overloaded_ibiP', 'Overloaded_ibib',
-                                'Overloaded_ibid', 'Overloaded_ibii',
-                                'calculateArea', 'doublePlus', 'increment',
-                                'multiplyPointCoordsPlusValue', 'name',
-                                'pointToPair', 'overloaded', 'power',
-                                'timesTen'])
-        self.assertTrue(expected_members.issubset(dir(Modifications)))
-
     def testRenamedMethodAvailability(self):
         '''Test if Modification class really have renamed the 'className' virtual method to 'name'.'''
         self.assertTrue('className' not in dir(Modifications))
diff --git a/sources/shiboken6/tests/samplebinding/namespace_test.py b/sources/shiboken6/tests/samplebinding/namespace_test.py
index 90e9c451d..9740a137d 100644
--- a/sources/shiboken6/tests/samplebinding/namespace_test.py
+++ b/sources/shiboken6/tests/samplebinding/namespace_test.py
@@ -46,16 +46,13 @@ class TestClassesUnderNamespace(unittest.TestCase):
         self.assertEqual(str(SampleNamespace.SomeClass),
             "<class 'sample.SampleNamespace.SomeClass'>")
         self.assertEqual(str(SampleNamespace.SomeClass.ProtectedEnum),
-            "<enum 'ProtectedEnum'>" if sys.pyside6_option_python_enum else
-            "<class 'sample.SampleNamespace.SomeClass.ProtectedEnum'>")
+            "<enum 'ProtectedEnum'>")
         self.assertEqual(str(SampleNamespace.SomeClass.SomeInnerClass.ProtectedEnum),
-            "<enum 'ProtectedEnum'>" if sys.pyside6_option_python_enum else
-            "<class 'sample.SampleNamespace.SomeClass.SomeInnerClass.ProtectedEnum'>")
+            "<enum '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.pyside6_option_python_enum else
-            "<class 'sample.SampleNamespace.SomeClass.SomeInnerClass.OkThisIsRecursiveEnough.NiceEnum'>")
+            "<enum 'NiceEnum'>")
 
         # Test if enum inside of class is correct represented
         self.assertEqual(objectFullname(get_signature(SampleNamespace.enumInEnumOut).parameters['in_'].annotation),
diff --git a/sources/shiboken6/tests/samplebinding/sample_test.py b/sources/shiboken6/tests/samplebinding/sample_test.py
index 45c47a4c9..c58322e20 100644
--- a/sources/shiboken6/tests/samplebinding/sample_test.py
+++ b/sources/shiboken6/tests/samplebinding/sample_test.py
@@ -18,32 +18,6 @@ import sample
 class ModuleTest(unittest.TestCase):
     '''Test case for module and global functions'''
 
-    @unittest.skipIf(sys.pyside6_option_python_enum, "Makes no sense with strict Enums")
-    def testModuleMembers(self):
-        '''Test availability of classes, global functions and other members on binding'''
-        expected_members = set(['Abstract', 'Derived', 'Point',
-                                'ListUser', 'PairUser', 'MapUser',
-                                'gimmeComplexList', 'gimmeDouble', 'gimmeInt',
-                                'makeCString', 'multiplyPair', 'returnCString',
-                                'SampleNamespace', 'transmuteComplexIntoPoint',
-                                'transmutePointIntoComplex', 'sumComplexPair',
-                                'FirstThing', 'SecondThing', 'ThirdThing',
-                                'GlobalEnum', 'NoThing'])
-        self.assertTrue(expected_members.issubset(dir(sample)))
-
-    @unittest.skipIf(sys.pyside6_option_python_enum, "Makes no sense with strict Enums")
-    def testAbstractPrintFormatEnum(self):
-        '''Test availability of PrintFormat enum from Abstract class'''
-        enum_members = set(['PrintFormat', 'Short', 'Verbose',
-                            'OnlyId', 'ClassNameAndId'])
-        self.assertTrue(enum_members.issubset(dir(sample.Abstract)))
-
-    @unittest.skipIf(sys.pyside6_option_python_enum, "Makes no sense with strict Enums")
-    def testSampleNamespaceOptionEnum(self):
-        '''Test availability of Option enum from SampleNamespace namespace'''
-        enum_members = set(['Option', 'None_', 'RandomNumber', 'UnixTime'])
-        self.assertTrue(enum_members.issubset(dir(sample.SampleNamespace)))
-
     def testAddedFunctionAtModuleLevel(self):
         '''Calls function added to module from type system description.'''
         str1 = 'Foo'