summaryrefslogtreecommitdiffstats
path: root/Lib/test/test_enum.py
diff options
context:
space:
mode:
Diffstat (limited to 'Lib/test/test_enum.py')
-rw-r--r--Lib/test/test_enum.py389
1 files changed, 388 insertions, 1 deletions
diff --git a/Lib/test/test_enum.py b/Lib/test/test_enum.py
index 630b155..4a732f9 100644
--- a/Lib/test/test_enum.py
+++ b/Lib/test/test_enum.py
@@ -3,9 +3,10 @@ import inspect
import pydoc
import unittest
from collections import OrderedDict
-from enum import Enum, IntEnum, EnumMeta, unique
+from enum import EnumMeta, Enum, IntEnum, AutoEnum, unique
from io import StringIO
from pickle import dumps, loads, PicklingError, HIGHEST_PROTOCOL
+from test import support
# for pickle tests
try:
@@ -283,6 +284,28 @@ class TestEnum(unittest.TestCase):
class Wrong(Enum):
_any_name_ = 9
+ def test_bool(self):
+ # plain Enum members are always True
+ class Logic(Enum):
+ true = True
+ false = False
+ self.assertTrue(Logic.true)
+ self.assertTrue(Logic.false)
+ # unless overridden
+ class RealLogic(Enum):
+ true = True
+ false = False
+ def __bool__(self):
+ return bool(self._value_)
+ self.assertTrue(RealLogic.true)
+ self.assertFalse(RealLogic.false)
+ # mixed Enums depend on mixed-in type
+ class IntLogic(int, Enum):
+ true = 1
+ false = 0
+ self.assertTrue(IntLogic.true)
+ self.assertFalse(IntLogic.false)
+
def test_contains(self):
Season = self.Season
self.assertIn(Season.AUTUMN, Season)
@@ -1547,6 +1570,328 @@ class TestEnum(unittest.TestCase):
self.assertEqual(LabelledList.unprocessed, 1)
self.assertEqual(LabelledList(1), LabelledList.unprocessed)
+ def test_ignore_as_str(self):
+ from datetime import timedelta
+ class Period(Enum, ignore='Period i'):
+ """
+ different lengths of time
+ """
+ def __new__(cls, value, period):
+ obj = object.__new__(cls)
+ obj._value_ = value
+ obj.period = period
+ return obj
+ Period = vars()
+ for i in range(367):
+ Period['Day%d' % i] = timedelta(days=i), 'day'
+ for i in range(53):
+ Period['Week%d' % i] = timedelta(days=i*7), 'week'
+ for i in range(13):
+ Period['Month%d' % i] = i, 'month'
+ OneDay = Day1
+ OneWeek = Week1
+ self.assertEqual(Period.Day7.value, timedelta(days=7))
+ self.assertEqual(Period.Day7.period, 'day')
+
+ def test_ignore_as_list(self):
+ from datetime import timedelta
+ class Period(Enum, ignore=['Period', 'i']):
+ """
+ different lengths of time
+ """
+ def __new__(cls, value, period):
+ obj = object.__new__(cls)
+ obj._value_ = value
+ obj.period = period
+ return obj
+ Period = vars()
+ for i in range(367):
+ Period['Day%d' % i] = timedelta(days=i), 'day'
+ for i in range(53):
+ Period['Week%d' % i] = timedelta(days=i*7), 'week'
+ for i in range(13):
+ Period['Month%d' % i] = i, 'month'
+ OneDay = Day1
+ OneWeek = Week1
+ self.assertEqual(Period.Day7.value, timedelta(days=7))
+ self.assertEqual(Period.Day7.period, 'day')
+
+ def test_new_with_no_value_and_int_base_class(self):
+ class NoValue(int, Enum):
+ def __new__(cls, value):
+ obj = int.__new__(cls, value)
+ obj.index = len(cls.__members__)
+ return obj
+ this = 1
+ that = 2
+ self.assertEqual(list(NoValue), [NoValue.this, NoValue.that])
+ self.assertEqual(NoValue.this, 1)
+ self.assertEqual(NoValue.this.value, 1)
+ self.assertEqual(NoValue.this.index, 0)
+ self.assertEqual(NoValue.that, 2)
+ self.assertEqual(NoValue.that.value, 2)
+ self.assertEqual(NoValue.that.index, 1)
+
+ def test_new_with_no_value(self):
+ class NoValue(Enum):
+ def __new__(cls, value):
+ obj = object.__new__(cls)
+ obj.index = len(cls.__members__)
+ return obj
+ this = 1
+ that = 2
+ self.assertEqual(list(NoValue), [NoValue.this, NoValue.that])
+ self.assertEqual(NoValue.this.value, 1)
+ self.assertEqual(NoValue.this.index, 0)
+ self.assertEqual(NoValue.that.value, 2)
+ self.assertEqual(NoValue.that.index, 1)
+
+
+class TestAutoNumber(unittest.TestCase):
+
+ def test_autonumbering(self):
+ class Color(AutoEnum):
+ red
+ green
+ blue
+ self.assertEqual(list(Color), [Color.red, Color.green, Color.blue])
+ self.assertEqual(Color.red.value, 1)
+ self.assertEqual(Color.green.value, 2)
+ self.assertEqual(Color.blue.value, 3)
+
+ def test_autointnumbering(self):
+ class Color(int, AutoEnum):
+ red
+ green
+ blue
+ self.assertTrue(isinstance(Color.red, int))
+ self.assertEqual(Color.green, 2)
+ self.assertTrue(Color.blue > Color.red)
+
+ def test_autonumbering_with_start(self):
+ class Color(AutoEnum, start=7):
+ red
+ green
+ blue
+ self.assertEqual(list(Color), [Color.red, Color.green, Color.blue])
+ self.assertEqual(Color.red.value, 7)
+ self.assertEqual(Color.green.value, 8)
+ self.assertEqual(Color.blue.value, 9)
+
+ def test_autonumbering_with_start_and_skip(self):
+ class Color(AutoEnum, start=7):
+ red
+ green
+ blue = 11
+ brown
+ self.assertEqual(list(Color), [Color.red, Color.green, Color.blue, Color.brown])
+ self.assertEqual(Color.red.value, 7)
+ self.assertEqual(Color.green.value, 8)
+ self.assertEqual(Color.blue.value, 11)
+ self.assertEqual(Color.brown.value, 12)
+
+
+ def test_badly_overridden_ignore(self):
+ with self.assertRaisesRegex(TypeError, "'int' object is not callable"):
+ class Color(AutoEnum):
+ _ignore_ = ()
+ red
+ green
+ blue
+ @property
+ def whatever(self):
+ pass
+ with self.assertRaisesRegex(TypeError, "'int' object is not callable"):
+ class Color(AutoEnum, ignore=None):
+ red
+ green
+ blue
+ @property
+ def whatever(self):
+ pass
+ with self.assertRaisesRegex(TypeError, "'int' object is not callable"):
+ class Color(AutoEnum, ignore='classmethod staticmethod'):
+ red
+ green
+ blue
+ @property
+ def whatever(self):
+ pass
+
+ def test_property(self):
+ class Color(AutoEnum):
+ red
+ green
+ blue
+ @property
+ def cap_name(self):
+ return self.name.title()
+ self.assertEqual(Color.blue.cap_name, 'Blue')
+
+ def test_magic_turns_off(self):
+ with self.assertRaisesRegex(NameError, "brown"):
+ class Color(AutoEnum):
+ red
+ green
+ blue
+ @property
+ def cap_name(self):
+ return self.name.title()
+ brown
+
+ with self.assertRaisesRegex(NameError, "rose"):
+ class Color(AutoEnum):
+ red
+ green
+ blue
+ def hello(self):
+ print('Hello! My serial is %s.' % self.value)
+ rose
+
+ with self.assertRaisesRegex(NameError, "cyan"):
+ class Color(AutoEnum):
+ red
+ green
+ blue
+ def __init__(self, *args):
+ pass
+ cyan
+
+
+class TestGenerateMethod(unittest.TestCase):
+
+ def test_autonaming(self):
+ class Color(Enum):
+ def _generate_next_value_(name, start, count, last_value):
+ return name
+ Red
+ Green
+ Blue
+ self.assertEqual(list(Color), [Color.Red, Color.Green, Color.Blue])
+ self.assertEqual(Color.Red.value, 'Red')
+ self.assertEqual(Color.Green.value, 'Green')
+ self.assertEqual(Color.Blue.value, 'Blue')
+
+ def test_autonamestr(self):
+ class Color(str, Enum):
+ def _generate_next_value_(name, start, count, last_value):
+ return name
+ Red
+ Green
+ Blue
+ self.assertTrue(isinstance(Color.Red, str))
+ self.assertEqual(Color.Green, 'Green')
+ self.assertTrue(Color.Blue < Color.Red)
+
+ def test_generate_as_staticmethod(self):
+ class Color(str, Enum):
+ @staticmethod
+ def _generate_next_value_(name, start, count, last_value):
+ return name.lower()
+ Red
+ Green
+ Blue
+ self.assertTrue(isinstance(Color.Red, str))
+ self.assertEqual(Color.Green, 'green')
+ self.assertTrue(Color.Blue < Color.Red)
+
+
+ def test_overridden_ignore(self):
+ with self.assertRaisesRegex(TypeError, "'str' object is not callable"):
+ class Color(Enum):
+ def _generate_next_value_(name, start, count, last_value):
+ return name
+ _ignore_ = ()
+ red
+ green
+ blue
+ @property
+ def whatever(self):
+ pass
+ with self.assertRaisesRegex(TypeError, "'str' object is not callable"):
+ class Color(Enum, ignore=None):
+ def _generate_next_value_(name, start, count, last_value):
+ return name
+ red
+ green
+ blue
+ @property
+ def whatever(self):
+ pass
+
+ def test_property(self):
+ class Color(Enum):
+ def _generate_next_value_(name, start, count, last_value):
+ return name
+ red
+ green
+ blue
+ @property
+ def upper_name(self):
+ return self.name.upper()
+ self.assertEqual(Color.blue.upper_name, 'BLUE')
+
+ def test_magic_turns_off(self):
+ with self.assertRaisesRegex(NameError, "brown"):
+ class Color(Enum):
+ def _generate_next_value_(name, start, count, last_value):
+ return name
+ red
+ green
+ blue
+ @property
+ def cap_name(self):
+ return self.name.title()
+ brown
+
+ with self.assertRaisesRegex(NameError, "rose"):
+ class Color(Enum):
+ def _generate_next_value_(name, start, count, last_value):
+ return name
+ red
+ green
+ blue
+ def hello(self):
+ print('Hello! My value %s.' % self.value)
+ rose
+
+ with self.assertRaisesRegex(NameError, "cyan"):
+ class Color(Enum):
+ def _generate_next_value_(name, start, count, last_value):
+ return name
+ red
+ green
+ blue
+ def __init__(self, *args):
+ pass
+ cyan
+
+ def test_powers_of_two(self):
+ class Bits(Enum):
+ def _generate_next_value_(name, start, count, last_value):
+ return 2 ** count
+ one
+ two
+ four
+ eight
+ self.assertEqual(Bits.one.value, 1)
+ self.assertEqual(Bits.two.value, 2)
+ self.assertEqual(Bits.four.value, 4)
+ self.assertEqual(Bits.eight.value, 8)
+
+ def test_powers_of_two_as_int(self):
+ class Bits(int, Enum):
+ def _generate_next_value_(name, start, count, last_value):
+ return 2 ** count
+ one
+ two
+ four
+ eight
+ self.assertEqual(Bits.one, 1)
+ self.assertEqual(Bits.two, 2)
+ self.assertEqual(Bits.four, 4)
+ self.assertEqual(Bits.eight, 8)
+
class TestUnique(unittest.TestCase):
@@ -1739,5 +2084,47 @@ class TestStdLib(unittest.TestCase):
if failed:
self.fail("result does not equal expected, see print above")
+
+class MiscTestCase(unittest.TestCase):
+ def test__all__(self):
+ support.check__all__(self, enum)
+
+
+# These are unordered here on purpose to ensure that declaration order
+# makes no difference.
+CONVERT_TEST_NAME_D = 5
+CONVERT_TEST_NAME_C = 5
+CONVERT_TEST_NAME_B = 5
+CONVERT_TEST_NAME_A = 5 # This one should sort first.
+CONVERT_TEST_NAME_E = 5
+CONVERT_TEST_NAME_F = 5
+
+class TestIntEnumConvert(unittest.TestCase):
+ def test_convert_value_lookup_priority(self):
+ test_type = enum.IntEnum._convert(
+ 'UnittestConvert', 'test.test_enum',
+ filter=lambda x: x.startswith('CONVERT_TEST_'))
+ # We don't want the reverse lookup value to vary when there are
+ # multiple possible names for a given value. It should always
+ # report the first lexigraphical name in that case.
+ self.assertEqual(test_type(5).name, 'CONVERT_TEST_NAME_A')
+
+ def test_convert(self):
+ test_type = enum.IntEnum._convert(
+ 'UnittestConvert', 'test.test_enum',
+ filter=lambda x: x.startswith('CONVERT_TEST_'))
+ # Ensure that test_type has all of the desired names and values.
+ self.assertEqual(test_type.CONVERT_TEST_NAME_F,
+ test_type.CONVERT_TEST_NAME_A)
+ self.assertEqual(test_type.CONVERT_TEST_NAME_B, 5)
+ self.assertEqual(test_type.CONVERT_TEST_NAME_C, 5)
+ self.assertEqual(test_type.CONVERT_TEST_NAME_D, 5)
+ self.assertEqual(test_type.CONVERT_TEST_NAME_E, 5)
+ # Ensure that test_type only picked up names matching the filter.
+ self.assertEqual([name for name in dir(test_type)
+ if name[0:2] not in ('CO', '__')],
+ [], msg='Names other than CONVERT_TEST_* found.')
+
+
if __name__ == '__main__':
unittest.main()
generated by cgit v0.12 at 2025-11-27 00:21:00 (GMT)