Minor fixes and unit tests

Author: jhonabreul

src/embed_tests/ClassManagerTests.cs

@@ -1056,6 +1056,33 @@ def is_enum_value_defined(value):
                 }
             }
         }
+
+        [Test]
+        public void EnumInterableOperationsNotSupportedForManagedNonEnumTypes()
+        {
+            using (Py.GIL())
+            {
+                var module = PyModule.FromString("EnumInterableOperationsNotSupportedForManagedNonEnumTypes", $@"
+from clr import AddReference
+AddReference(""Python.EmbeddingTest"")
+
+from Python.EmbeddingTest import *
+
+def get_enum_values():
+    return [x for x in ClassManagerTests]
+
+def count_enum_values():
+    return len(ClassManagerTests)
+
+def is_enum_value_defined():
+    return 1 in ClassManagerTests
+                    ");
+
+                Assert.Throws<PythonException>(() => module.InvokeMethod("get_enum_values"));
+                Assert.Throws<PythonException>(() => module.InvokeMethod("count_enum_values"));
+                Assert.Throws<PythonException>(() => module.InvokeMethod("is_enum_value_defined"));
+            }
+        }
     }
 
     public class NestedTestParent

src/runtime/Types/MetaType.cs

@@ -366,7 +366,10 @@ public static NewReference __subclasscheck__(BorrowedReference tp, BorrowedRefer
         /// </summary>
         public static NewReference tp_iter(BorrowedReference tp)
         {
-            var type = CheckAndGetEnumType(tp);
+            if (!TryGetEnumType(tp, out var type))
+            {
+                return default;
+            }
             var values = Enum.GetValues(type);
             return new Iterator(values.GetEnumerator(), type).Alloc();
         }
@@ -376,7 +379,10 @@ public static NewReference tp_iter(BorrowedReference tp)
         /// </summary>
         public static int mp_length(BorrowedReference tp)
         {
-            var type = CheckAndGetEnumType(tp);
+            if (!TryGetEnumType(tp, out var type))
+            {
+                return -1;
+            }
             return Enum.GetValues(type).Length;
         }
 
@@ -385,38 +391,47 @@ public static int mp_length(BorrowedReference tp)
         /// </summary>
         public static int sq_contains(BorrowedReference tp, BorrowedReference v)
         {
-            var type = CheckAndGetEnumType(tp);
+            if (!TryGetEnumType(tp, out var type))
+            {
+                return -1;
+            }
 
             if (!Converter.ToManaged(v, type, out var enumValue, false) &&
                 !Converter.ToManaged(v, typeof(int), out enumValue, false) &&
                 !Converter.ToManaged(v, typeof(string), out enumValue, false))
             {
                 Exceptions.SetError(Exceptions.TypeError,
                     $"invalid parameter type for sq_contains: should be {Converter.GetTypeByAlias(v)}, found {type}");
+                return -1;
             }
+
             return Enum.IsDefined(type, enumValue) ? 1 : 0;
         }
 
-        private static Type CheckAndGetEnumType(BorrowedReference tp)
+        private static bool TryGetEnumType(BorrowedReference tp, out Type type)
         {
+            type = null;
             var cb = GetManagedObject(tp) as ClassBase;
             if (cb == null)
             {
                 Exceptions.SetError(Exceptions.TypeError, "invalid object");
+                return false;
             }
 
             if (!cb.type.Valid)
             {
                 Exceptions.SetError(Exceptions.TypeError, "invalid type");
+                return false;
             }
 
-            var type = cb.type.Value;
-            if (!type.IsEnum)
+            if (!cb.type.Value.IsEnum)
             {
-                Exceptions.SetError(Exceptions.TypeError, "uniterable object");
+                Exceptions.SetError(Exceptions.TypeError, "uniterable type");
+                return false;
             }
 
-            return type;
+            type = cb.type.Value;
+            return true;
         }
     }
 }