tests/basics: Add skip detection for metaclass and enum tests.

Adds feature detection to skip tests when required features are not
available (e.g. in minimal/standard build variants).

- class_metaclass_init.py: Skip if MICROPY_PY_METACLASS_INIT disabled
- class_metaclass_property.py: Skip if MICROPY_PY_METACLASS_PROPERTIES disabled
- class_metaclass_prepare.py: Already had skip for __prepare__
- enum_auto.py: Add enum import check before __prepare__ check
- enum_flag.py: Skip if enum or __prepare__ not available
- enum_strenum.py: Skip if enum module not available
- metaclass.py: Skip if MICROPY_PY_METACLASS_INIT disabled

This fixes CI failures on build variants where these features are
disabled by config.

Signed-off-by: Andrew Leech <[email protected]>

Author: pi-anl

tests/basics/class_metaclass_init.py

@@ -1,3 +1,20 @@
+# Test metaclass __init__ support (requires MICROPY_PY_METACLASS_INIT)
+
+# Skip test if metaclass __init__ is not supported
+_init_test = []
+
+class _TestMeta(type):
+    def __init__(cls, name, bases, attrs):
+        super().__init__(name, bases, attrs)
+        _init_test.append(1)
+
+class _Test(metaclass=_TestMeta):
+    pass
+
+if not _init_test:
+    print("SKIP")
+    raise SystemExit
+
 # Test 1: Basic metaclass __init__ call
 init_called = []
 

tests/basics/class_metaclass_prepare.py

@@ -1,14 +1,25 @@
 # Test metaclass __prepare__ method (PEP 3115)
 
+# Skip test if classmethod builtin is not available
+try:
+    classmethod
+except NameError:
+    print("SKIP")
+    raise SystemExit
+
 # Skip test if __prepare__ is not supported
 _prepare_test = []
-class _TestMeta(type):
-    @classmethod
-    def __prepare__(mcs, name, bases):
-        _prepare_test.append(1)
-        return {}
 
-class _Test(metaclass=_TestMeta):
+try:
+    class _TestMeta(type):
+        @classmethod
+        def __prepare__(mcs, name, bases):
+            _prepare_test.append(1)
+            return {}
+
+    class _Test(metaclass=_TestMeta):
+        pass
+except:
     pass
 
 if not _prepare_test:
@@ -22,7 +33,7 @@ class _Test(metaclass=_TestMeta):
 class Meta1(type):
     @classmethod
     def __prepare__(mcs, name, bases):
-        prepare_log.append(f"__prepare__({name})")
+        prepare_log.append("__prepare__(%s)" % (name,))
         return {}
 
 class Test1(metaclass=Meta1):
@@ -37,7 +48,7 @@ class Test1(metaclass=Meta1):
 class Meta2(type):
     @classmethod
     def __prepare__(mcs, name, bases):
-        print(f"mcs={mcs.__name__}, name={name}, bases={bases}")
+        print("mcs=%s, name=%s, bases=%s" % (mcs.__name__, name, bases))
         return {}
 
 class Base2:
@@ -58,7 +69,7 @@ def __prepare__(mcs, name, bases):
 class Test3(metaclass=Meta3):
     pass
 
-print(f"Test3.injected = {Test3.injected}")
+print("Test3.injected = %s" % (Test3.injected))
 print("PASS" if Test3.injected == 42 else "FAIL")
 
 # Test 4: __prepare__ can access namespace in __new__
@@ -82,7 +93,7 @@ def __new__(mcs, name, bases, namespace):
 class Test4(metaclass=Meta4):
     x = 1
 
-print(f"Was prepared: {Test4._was_prepared}")
+print("Was prepared: %s" % (Test4._was_prepared))
 print("PASS" if Test4._was_prepared else "FAIL")
 
 # Test 5: __prepare__ inheritance
@@ -91,7 +102,7 @@ class Test4(metaclass=Meta4):
 class BaseMeta(type):
     @classmethod
     def __prepare__(mcs, name, bases):
-        print(f"BaseMeta.__prepare__({name})")
+        print("BaseMeta.__prepare__(%s)" % (name))
         return {}
 
 class DerivedMeta(BaseMeta):
@@ -109,7 +120,7 @@ class Meta6(type):
 class Test6(metaclass=Meta6):
     x = 1
 
-print(f"Test6.x = {Test6.x}")
+print("Test6.x = %s" % (Test6.x))
 print("PASS")
 
 print("\nAll __prepare__ tests completed!")

tests/basics/class_metaclass_property.py

@@ -1,3 +1,32 @@
+# Test metaclass property/method support (requires MICROPY_PY_METACLASS_PROPERTIES)
+
+# Skip test if property builtin is not available
+try:
+    property
+except NameError:
+    print("SKIP")
+    raise SystemExit
+
+# Skip test if metaclass property access is not supported
+_property_test = None
+
+try:
+    class _TestMeta(type):
+        @property
+        def test_prop(cls):
+            return "works"
+
+    class _Test(metaclass=_TestMeta):
+        pass
+
+    _property_test = _Test.test_prop
+except (AttributeError, TypeError):
+    pass
+
+if _property_test != "works":
+    print("SKIP")
+    raise SystemExit
+
 # Test 1: Metaclass property access
 class Meta(type):
     @property

tests/basics/enum_auto.py

@@ -1,33 +1,48 @@
 # Test enum.auto() support (requires MICROPY_PY_METACLASS_PREPARE)
 
+# Skip test if enum module is not available
+try:
+    from enum import Enum, IntEnum, auto
+except ImportError:
+    print("SKIP")
+    raise SystemExit
+
+# Skip test if classmethod builtin is not available
+try:
+    classmethod
+except NameError:
+    print("SKIP")
+    raise SystemExit
+
 # Skip test if __prepare__ is not supported
 _prepare_test = []
-class _TestMeta(type):
-    @classmethod
-    def __prepare__(mcs, name, bases):
-        _prepare_test.append(1)
-        return {}
 
-class _Test(metaclass=_TestMeta):
+try:
+    class _TestMeta(type):
+        @classmethod
+        def __prepare__(mcs, name, bases):
+            _prepare_test.append(1)
+            return {}
+
+    class _Test(metaclass=_TestMeta):
+        pass
+except:
     pass
 
 if not _prepare_test:
     print("SKIP")
     raise SystemExit
 
-# Now run the actual tests
-from enum import Enum, IntEnum, auto
-
 # Test 1: Basic auto() usage - sequential values starting from 1
 print("Test 1: Basic auto() usage")
 class Color(Enum):
     RED = auto()
     GREEN = auto()
     BLUE = auto()
 
-print(f"RED.value = {Color.RED.value}")
-print(f"GREEN.value = {Color.GREEN.value}")
-print(f"BLUE.value = {Color.BLUE.value}")
+print("RED.value = %s" % (Color.RED.value))
+print("GREEN.value = %s" % (Color.GREEN.value))
+print("BLUE.value = %s" % (Color.BLUE.value))
 print("PASS" if (Color.RED.value == 1 and Color.GREEN.value == 2 and Color.BLUE.value == 3) else "FAIL")
 
 # Test 2: Mixed auto() and explicit values
@@ -39,10 +54,10 @@ class Status(Enum):
     PAUSED = auto()
     STOPPED = auto()
 
-print(f"PENDING.value = {Status.PENDING.value}")
-print(f"ACTIVE.value = {Status.ACTIVE.value}")
-print(f"PAUSED.value = {Status.PAUSED.value}")
-print(f"STOPPED.value = {Status.STOPPED.value}")
+print("PENDING.value = %s" % (Status.PENDING.value))
+print("ACTIVE.value = %s" % (Status.ACTIVE.value))
+print("PAUSED.value = %s" % (Status.PAUSED.value))
+print("STOPPED.value = %s" % (Status.STOPPED.value))
 # In MicroPython, auto() starts at max(explicit) + 1, then assigns in creation order
 # PENDING, PAUSED, STOPPED were created in that order, so they get 11, 12, 13
 print("PASS" if (Status.ACTIVE.value == 10 and
@@ -56,17 +71,17 @@ class Priority(IntEnum):
     MEDIUM = auto()
     HIGH = auto()
 
-print(f"LOW.value = {Priority.LOW.value}")
-print(f"MEDIUM.value = {Priority.MEDIUM.value}")
-print(f"HIGH.value = {Priority.HIGH.value}")
+print("LOW.value = %s" % (Priority.LOW.value))
+print("MEDIUM.value = %s" % (Priority.MEDIUM.value))
+print("HIGH.value = %s" % (Priority.HIGH.value))
 print("PASS" if (Priority.LOW.value == 1 and Priority.MEDIUM.value == 2 and Priority.HIGH.value == 3) else "FAIL")
 
 # Test 4: auto() with single member
 print("\nTest 4: auto() with single member")
 class Single(Enum):
     ONLY = auto()
 
-print(f"ONLY.value = {Single.ONLY.value}")
+print("ONLY.value = %s" % (Single.ONLY.value))
 print("PASS" if Single.ONLY.value == 1 else "FAIL")
 
 # Test 5: All auto() values
@@ -79,7 +94,7 @@ class AllAuto(Enum):
     E = auto()
 
 values = [AllAuto.A.value, AllAuto.B.value, AllAuto.C.value, AllAuto.D.value, AllAuto.E.value]
-print(f"Values: {values}")
+print("Values: %s" % (values))
 print("PASS" if values == [1, 2, 3, 4, 5] else "FAIL")
 
 # Test 6: auto() after explicit value 0
@@ -89,9 +104,9 @@ class StartZero(Enum):
     ONE = auto()
     TWO = auto()
 
-print(f"ZERO.value = {StartZero.ZERO.value}")
-print(f"ONE.value = {StartZero.ONE.value}")
-print(f"TWO.value = {StartZero.TWO.value}")
+print("ZERO.value = %s" % (StartZero.ZERO.value))
+print("ONE.value = %s" % (StartZero.ONE.value))
+print("TWO.value = %s" % (StartZero.TWO.value))
 print("PASS" if (StartZero.ZERO.value == 0 and StartZero.ONE.value == 1 and StartZero.TWO.value == 2) else "FAIL")
 
 # Test 7: auto() continues from highest explicit value
@@ -103,11 +118,11 @@ class Complex(Enum):
     D = 50
     E = auto()
 
-print(f"A.value = {Complex.A.value}")
-print(f"B.value = {Complex.B.value}")
-print(f"C.value = {Complex.C.value}")
-print(f"D.value = {Complex.D.value}")
-print(f"E.value = {Complex.E.value}")
+print("A.value = %s" % (Complex.A.value))
+print("B.value = %s" % (Complex.B.value))
+print("C.value = %s" % (Complex.C.value))
+print("D.value = %s" % (Complex.D.value))
+print("E.value = %s" % (Complex.E.value))
 # In MicroPython: auto() starts at max(100, 50) + 1 = 101
 # A, C, E created in that order get 101, 102, 103
 print("PASS" if (Complex.B.value == 100 and Complex.D.value == 50 and
@@ -123,21 +138,21 @@ class Direction(Enum):
 
 # Test iteration
 directions = [d for d in Direction]
-print(f"Member count: {len(directions)}")
+print("Member count: %s" % (len(directions)))
 print("PASS" if len(directions) == 4 else "FAIL")
 
 # Test value lookup
 try:
     north = Direction(1)
-    print(f"Direction(1) = {north.name}")
+    print("Direction(1) = %s" % (north.name))
     print("PASS" if north == Direction.NORTH else "FAIL")
 except ValueError:
     print("FAIL - value lookup failed")
 
 # Test 9: auto() repr
 print("\nTest 9: auto() repr")
 a = auto()
-print(f"repr(auto()) = {repr(a)}")
+print("repr(auto()) = %s" % (repr(a)))
 print("PASS" if repr(a) == "auto()" else "FAIL")
 
 print("\nAll enum.auto() tests completed!")