Fix test_methoddispatch.test_missing_value (#1487)

Author: slozier

Src/IronPythonTest/Enums.cs

@@ -172,83 +172,33 @@ public enum EnumSByte : sbyte {
         MaxSByte = SByte.MaxValue,
     }
     public enum EnumByte : byte {
-        Zero = 0,
-        MaxSByte = (byte)SByte.MaxValue,
         MinByte = Byte.MinValue,
         MaxByte = Byte.MaxValue,
     }
     public enum EnumShort : short {
         Zero = 0,
-        MinSByte = SByte.MinValue,
-        MaxSByte = SByte.MaxValue,
-        MinByte = Byte.MinValue,
-        MaxByte = Byte.MaxValue,
         MinShort = Int16.MinValue,
         MaxShort = Int16.MaxValue,
     }
     public enum EnumUShort : ushort {
-        Zero = 0,
-        MaxSByte = (ushort)SByte.MaxValue,
-        MinByte = Byte.MinValue,
-        MaxByte = Byte.MaxValue,
-        MaxShort = (ushort)Int16.MaxValue,
         MinUShort = UInt16.MinValue,
         MaxUShort = UInt16.MaxValue,
     }
     public enum EnumInt : int {
         Zero = 0,
-        MinSByte = SByte.MinValue,
-        MaxSByte = SByte.MaxValue,
-        MinByte = Byte.MinValue,
-        MaxByte = Byte.MaxValue,
-        MinShort = Int16.MinValue,
-        MaxShort = Int16.MaxValue,
-        MinUShort = UInt16.MinValue,
-        MaxUShort = UInt16.MaxValue,
         MinInt = Int32.MinValue,
         MaxInt = Int32.MaxValue,
     }
     public enum EnumUInt : uint {
-        Zero = 0,
-        MaxSByte = (uint)SByte.MaxValue,
-        MinByte = Byte.MinValue,
-        MaxByte = Byte.MaxValue,
-        MaxShort = (uint)Int16.MaxValue,
-        MinUShort = UInt16.MinValue,
-        MaxUShort = UInt16.MaxValue,
-        MaxInt = Int32.MaxValue,
         MinUInt = UInt32.MinValue,
         MaxUInt = UInt32.MaxValue,
     }
     public enum EnumLong : long {
         Zero = 0,
-        MinSByte = SByte.MinValue,
-        MaxSByte = SByte.MaxValue,
-        MinByte = Byte.MinValue,
-        MaxByte = Byte.MaxValue,
-        MinShort = Int16.MinValue,
-        MaxShort = Int16.MaxValue,
-        MinUShort = UInt16.MinValue,
-        MaxUShort = UInt16.MaxValue,
-        MinInt = Int32.MinValue,
-        MaxInt = Int32.MaxValue,
-        MinUInt = UInt32.MinValue,
-        MaxUInt = UInt32.MaxValue,
         MinLong = Int64.MinValue,
         MaxLong = Int64.MaxValue,
     }
     public enum EnumULong : ulong {
-        Zero = 0,
-        MaxSByte = (ulong)SByte.MaxValue,
-        MinByte = Byte.MinValue,
-        MaxByte = Byte.MaxValue,
-        MaxShort = (ulong)Int16.MaxValue,
-        MinUShort = UInt16.MinValue,
-        MaxUShort = UInt16.MaxValue,
-        MaxInt = Int32.MaxValue,
-        MinUInt = UInt32.MinValue,
-        MaxUInt = UInt32.MaxValue,
-        MaxLong = Int64.MaxValue,
         MinULong = UInt64.MinValue,
         MaxULong = UInt64.MaxValue,
     }

Tests/test_methoddispatch.py

@@ -884,25 +884,20 @@ def test_missing_value(self):
         self.assertEqual(tst.Test_44(), "(Structure)IronPythonTest.Structure")
         self.assertEqual(tst.Test_45(), "(EnumSByte)Zero")
         self.assertEqual(tst.Test_46(), "(EnumSByte)Zero")
-        # TODO: determine if this is a mono bug or not
-        # both Zero and MinByte have the value of 0, Mono
-        # https://github.com/IronLanguages/main/issues/1596
-        if not is_mono:
-            self.assertEqual(tst.Test_47(), "(EnumByte)Zero")
-            self.assertEqual(tst.Test_48(), "(EnumByte)Zero")
-            self.assertEqual(tst.Test_49(), "(EnumShort)Zero")
-            self.assertEqual(tst.Test_50(), "(EnumShort)Zero")
-            self.assertEqual(tst.Test_51(), "(EnumUShort)Zero")
-            self.assertEqual(tst.Test_52(), "(EnumUShort)Zero")
-        self.assertEqual(tst.Test_53(), "(EnumInt)MinUShort")
-        self.assertEqual(tst.Test_54(), "(EnumInt)MinUShort")
-        if not is_mono:
-            self.assertEqual(tst.Test_55(), "(EnumUInt)MinUInt")
-            self.assertEqual(tst.Test_56(), "(EnumUInt)MinUInt")
-            self.assertEqual(tst.Test_57(), "(EnumLong)MinUInt")
-            self.assertEqual(tst.Test_58(), "(EnumLong)MinUInt")
-            self.assertEqual(tst.Test_59(), "(EnumULong)MinUInt")
-            self.assertEqual(tst.Test_60(), "(EnumULong)MinUInt")
+        self.assertEqual(tst.Test_47(), "(EnumByte)MinByte")
+        self.assertEqual(tst.Test_48(), "(EnumByte)MinByte")
+        self.assertEqual(tst.Test_49(), "(EnumShort)Zero")
+        self.assertEqual(tst.Test_50(), "(EnumShort)Zero")
+        self.assertEqual(tst.Test_51(), "(EnumUShort)MinUShort")
+        self.assertEqual(tst.Test_52(), "(EnumUShort)MinUShort")
+        self.assertEqual(tst.Test_53(), "(EnumInt)Zero")
+        self.assertEqual(tst.Test_54(), "(EnumInt)Zero")
+        self.assertEqual(tst.Test_55(), "(EnumUInt)MinUInt")
+        self.assertEqual(tst.Test_56(), "(EnumUInt)MinUInt")
+        self.assertEqual(tst.Test_57(), "(EnumLong)Zero")
+        self.assertEqual(tst.Test_58(), "(EnumLong)Zero")
+        self.assertEqual(tst.Test_59(), "(EnumULong)MinULong")
+        self.assertEqual(tst.Test_60(), "(EnumULong)MinULong")
         self.assertEqual(tst.Test_61(), "(string)(null)")
         self.assertEqual(tst.Test_62(), "(string)(null)")
         self.assertEqual(tst.Test_63(), "(object)System.Reflection.Missing")

Tests/test_number.py

@@ -165,7 +165,7 @@ def type_test(tx, ty):
     @skipUnlessIronPython()
     def test_conversions(self):
         """implicit conversions (conversion defined on Derived)"""
-        from IronPythonTest import Base, Base2, ConversionStorage, Derived, Derived2, EnumByte, EnumInt, EnumLong, EnumSByte, EnumShort, EnumTest, EnumUShort, EnumUInt, EnumULong
+        from IronPythonTest import Base, Base2, ConversionStorage, Derived, Derived2
         a = ConversionStorage()
         b = Base(5)
         d = Derived(23)
@@ -245,55 +245,6 @@ def __pos__(self):
         a = None
         if a: self.assertEqual(False, True)
 
-        # Enum conversions
-
-        class EnumRec:
-            def __init__(self, code, min, max, enum, test):
-                self.code = code
-                self.min = min
-                self.max = max
-                self.enum = enum
-                self.test = test
-
-        enum_types = [
-            EnumRec("SByte", -128, 127, EnumSByte, EnumTest.TestEnumSByte),
-            EnumRec("Byte", 0, 255, EnumByte, EnumTest.TestEnumByte),
-            EnumRec("Short", -32768, 32767, EnumShort, EnumTest.TestEnumShort),
-            EnumRec("UShort", 0, 65535, EnumUShort, EnumTest.TestEnumUShort),
-            EnumRec("Int", -2147483648, 2147483647, EnumInt, EnumTest.TestEnumInt),
-            EnumRec("UInt", 0, 4294967295, EnumUInt, EnumTest.TestEnumUInt),
-            EnumRec("Long", -9223372036854775808, 9223372036854775807, EnumLong, EnumTest.TestEnumLong),
-            EnumRec("ULong", 0, 18446744073709551615, EnumULong, EnumTest.TestEnumULong),
-        ]
-
-        value_names = ["Zero"]
-        value_values = {"Zero" : 0}
-        for e in enum_types:
-            value_names.append("Min" + e.code)
-            value_names.append("Max" + e.code)
-            value_values["Min" + e.code] = e.min
-            value_values["Max" + e.code] = e.max
-
-        """
-        These tests are changed or obsoleted by new enum coercion rules
-        for enum in enum_types:
-            for name in value_names:
-                val = value_values[name]
-                if hasattr(enum.enum, name):
-                    for test in enum_types:
-                        func = test.test
-                        ev = getattr(enum.enum, name)
-                        if test.min <= val and val <= test.max:
-                            func(ev)
-                        else:
-                            try:
-                                func(ev)
-                            except:
-                                pass
-                            else:
-                                self.assertTrue(False)
-                        EnumTest.TestEnumBoolean(ev)
-        """
 
         self.assertEqual(int(Single.Parse("3.14159")), 3)