mirror of
https://github.com/python/cpython.git
synced 2025-01-06 00:25:19 +08:00
6f20bd6063
consistent name for values having multiple names. Ex: signal.Signals(6) now refers to itself as signal.SIGALRM rather than flipping between that and signal.SIGIOT based on the interpreter's hash randomization seed. This helps finish issue27167.
1809 lines
63 KiB
Python
1809 lines
63 KiB
Python
import enum
|
|
import inspect
|
|
import pydoc
|
|
import unittest
|
|
from collections import OrderedDict
|
|
from enum import Enum, IntEnum, EnumMeta, unique
|
|
from io import StringIO
|
|
from pickle import dumps, loads, PicklingError, HIGHEST_PROTOCOL
|
|
from test import support
|
|
|
|
# for pickle tests
|
|
try:
|
|
class Stooges(Enum):
|
|
LARRY = 1
|
|
CURLY = 2
|
|
MOE = 3
|
|
except Exception as exc:
|
|
Stooges = exc
|
|
|
|
try:
|
|
class IntStooges(int, Enum):
|
|
LARRY = 1
|
|
CURLY = 2
|
|
MOE = 3
|
|
except Exception as exc:
|
|
IntStooges = exc
|
|
|
|
try:
|
|
class FloatStooges(float, Enum):
|
|
LARRY = 1.39
|
|
CURLY = 2.72
|
|
MOE = 3.142596
|
|
except Exception as exc:
|
|
FloatStooges = exc
|
|
|
|
# for pickle test and subclass tests
|
|
try:
|
|
class StrEnum(str, Enum):
|
|
'accepts only string values'
|
|
class Name(StrEnum):
|
|
BDFL = 'Guido van Rossum'
|
|
FLUFL = 'Barry Warsaw'
|
|
except Exception as exc:
|
|
Name = exc
|
|
|
|
try:
|
|
Question = Enum('Question', 'who what when where why', module=__name__)
|
|
except Exception as exc:
|
|
Question = exc
|
|
|
|
try:
|
|
Answer = Enum('Answer', 'him this then there because')
|
|
except Exception as exc:
|
|
Answer = exc
|
|
|
|
try:
|
|
Theory = Enum('Theory', 'rule law supposition', qualname='spanish_inquisition')
|
|
except Exception as exc:
|
|
Theory = exc
|
|
|
|
# for doctests
|
|
try:
|
|
class Fruit(Enum):
|
|
tomato = 1
|
|
banana = 2
|
|
cherry = 3
|
|
except Exception:
|
|
pass
|
|
|
|
def test_pickle_dump_load(assertion, source, target=None):
|
|
if target is None:
|
|
target = source
|
|
for protocol in range(HIGHEST_PROTOCOL + 1):
|
|
assertion(loads(dumps(source, protocol=protocol)), target)
|
|
|
|
def test_pickle_exception(assertion, exception, obj):
|
|
for protocol in range(HIGHEST_PROTOCOL + 1):
|
|
with assertion(exception):
|
|
dumps(obj, protocol=protocol)
|
|
|
|
class TestHelpers(unittest.TestCase):
|
|
# _is_descriptor, _is_sunder, _is_dunder
|
|
|
|
def test_is_descriptor(self):
|
|
class foo:
|
|
pass
|
|
for attr in ('__get__','__set__','__delete__'):
|
|
obj = foo()
|
|
self.assertFalse(enum._is_descriptor(obj))
|
|
setattr(obj, attr, 1)
|
|
self.assertTrue(enum._is_descriptor(obj))
|
|
|
|
def test_is_sunder(self):
|
|
for s in ('_a_', '_aa_'):
|
|
self.assertTrue(enum._is_sunder(s))
|
|
|
|
for s in ('a', 'a_', '_a', '__a', 'a__', '__a__', '_a__', '__a_', '_',
|
|
'__', '___', '____', '_____',):
|
|
self.assertFalse(enum._is_sunder(s))
|
|
|
|
def test_is_dunder(self):
|
|
for s in ('__a__', '__aa__'):
|
|
self.assertTrue(enum._is_dunder(s))
|
|
for s in ('a', 'a_', '_a', '__a', 'a__', '_a_', '_a__', '__a_', '_',
|
|
'__', '___', '____', '_____',):
|
|
self.assertFalse(enum._is_dunder(s))
|
|
|
|
|
|
class TestEnum(unittest.TestCase):
|
|
|
|
def setUp(self):
|
|
class Season(Enum):
|
|
SPRING = 1
|
|
SUMMER = 2
|
|
AUTUMN = 3
|
|
WINTER = 4
|
|
self.Season = Season
|
|
|
|
class Konstants(float, Enum):
|
|
E = 2.7182818
|
|
PI = 3.1415926
|
|
TAU = 2 * PI
|
|
self.Konstants = Konstants
|
|
|
|
class Grades(IntEnum):
|
|
A = 5
|
|
B = 4
|
|
C = 3
|
|
D = 2
|
|
F = 0
|
|
self.Grades = Grades
|
|
|
|
class Directional(str, Enum):
|
|
EAST = 'east'
|
|
WEST = 'west'
|
|
NORTH = 'north'
|
|
SOUTH = 'south'
|
|
self.Directional = Directional
|
|
|
|
from datetime import date
|
|
class Holiday(date, Enum):
|
|
NEW_YEAR = 2013, 1, 1
|
|
IDES_OF_MARCH = 2013, 3, 15
|
|
self.Holiday = Holiday
|
|
|
|
def test_dir_on_class(self):
|
|
Season = self.Season
|
|
self.assertEqual(
|
|
set(dir(Season)),
|
|
set(['__class__', '__doc__', '__members__', '__module__',
|
|
'SPRING', 'SUMMER', 'AUTUMN', 'WINTER']),
|
|
)
|
|
|
|
def test_dir_on_item(self):
|
|
Season = self.Season
|
|
self.assertEqual(
|
|
set(dir(Season.WINTER)),
|
|
set(['__class__', '__doc__', '__module__', 'name', 'value']),
|
|
)
|
|
|
|
def test_dir_with_added_behavior(self):
|
|
class Test(Enum):
|
|
this = 'that'
|
|
these = 'those'
|
|
def wowser(self):
|
|
return ("Wowser! I'm %s!" % self.name)
|
|
self.assertEqual(
|
|
set(dir(Test)),
|
|
set(['__class__', '__doc__', '__members__', '__module__', 'this', 'these']),
|
|
)
|
|
self.assertEqual(
|
|
set(dir(Test.this)),
|
|
set(['__class__', '__doc__', '__module__', 'name', 'value', 'wowser']),
|
|
)
|
|
|
|
def test_dir_on_sub_with_behavior_on_super(self):
|
|
# see issue22506
|
|
class SuperEnum(Enum):
|
|
def invisible(self):
|
|
return "did you see me?"
|
|
class SubEnum(SuperEnum):
|
|
sample = 5
|
|
self.assertEqual(
|
|
set(dir(SubEnum.sample)),
|
|
set(['__class__', '__doc__', '__module__', 'name', 'value', 'invisible']),
|
|
)
|
|
|
|
def test_enum_in_enum_out(self):
|
|
Season = self.Season
|
|
self.assertIs(Season(Season.WINTER), Season.WINTER)
|
|
|
|
def test_enum_value(self):
|
|
Season = self.Season
|
|
self.assertEqual(Season.SPRING.value, 1)
|
|
|
|
def test_intenum_value(self):
|
|
self.assertEqual(IntStooges.CURLY.value, 2)
|
|
|
|
def test_enum(self):
|
|
Season = self.Season
|
|
lst = list(Season)
|
|
self.assertEqual(len(lst), len(Season))
|
|
self.assertEqual(len(Season), 4, Season)
|
|
self.assertEqual(
|
|
[Season.SPRING, Season.SUMMER, Season.AUTUMN, Season.WINTER], lst)
|
|
|
|
for i, season in enumerate('SPRING SUMMER AUTUMN WINTER'.split(), 1):
|
|
e = Season(i)
|
|
self.assertEqual(e, getattr(Season, season))
|
|
self.assertEqual(e.value, i)
|
|
self.assertNotEqual(e, i)
|
|
self.assertEqual(e.name, season)
|
|
self.assertIn(e, Season)
|
|
self.assertIs(type(e), Season)
|
|
self.assertIsInstance(e, Season)
|
|
self.assertEqual(str(e), 'Season.' + season)
|
|
self.assertEqual(
|
|
repr(e),
|
|
'<Season.{0}: {1}>'.format(season, i),
|
|
)
|
|
|
|
def test_value_name(self):
|
|
Season = self.Season
|
|
self.assertEqual(Season.SPRING.name, 'SPRING')
|
|
self.assertEqual(Season.SPRING.value, 1)
|
|
with self.assertRaises(AttributeError):
|
|
Season.SPRING.name = 'invierno'
|
|
with self.assertRaises(AttributeError):
|
|
Season.SPRING.value = 2
|
|
|
|
def test_changing_member(self):
|
|
Season = self.Season
|
|
with self.assertRaises(AttributeError):
|
|
Season.WINTER = 'really cold'
|
|
|
|
def test_attribute_deletion(self):
|
|
class Season(Enum):
|
|
SPRING = 1
|
|
SUMMER = 2
|
|
AUTUMN = 3
|
|
WINTER = 4
|
|
|
|
def spam(cls):
|
|
pass
|
|
|
|
self.assertTrue(hasattr(Season, 'spam'))
|
|
del Season.spam
|
|
self.assertFalse(hasattr(Season, 'spam'))
|
|
|
|
with self.assertRaises(AttributeError):
|
|
del Season.SPRING
|
|
with self.assertRaises(AttributeError):
|
|
del Season.DRY
|
|
with self.assertRaises(AttributeError):
|
|
del Season.SPRING.name
|
|
|
|
def test_bool_of_class(self):
|
|
class Empty(Enum):
|
|
pass
|
|
self.assertTrue(bool(Empty))
|
|
|
|
def test_bool_of_member(self):
|
|
class Count(Enum):
|
|
zero = 0
|
|
one = 1
|
|
two = 2
|
|
for member in Count:
|
|
self.assertTrue(bool(member))
|
|
|
|
def test_invalid_names(self):
|
|
with self.assertRaises(ValueError):
|
|
class Wrong(Enum):
|
|
mro = 9
|
|
with self.assertRaises(ValueError):
|
|
class Wrong(Enum):
|
|
_create_= 11
|
|
with self.assertRaises(ValueError):
|
|
class Wrong(Enum):
|
|
_get_mixins_ = 9
|
|
with self.assertRaises(ValueError):
|
|
class Wrong(Enum):
|
|
_find_new_ = 1
|
|
with self.assertRaises(ValueError):
|
|
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)
|
|
self.assertNotIn(3, Season)
|
|
|
|
val = Season(3)
|
|
self.assertIn(val, Season)
|
|
|
|
class OtherEnum(Enum):
|
|
one = 1; two = 2
|
|
self.assertNotIn(OtherEnum.two, Season)
|
|
|
|
def test_comparisons(self):
|
|
Season = self.Season
|
|
with self.assertRaises(TypeError):
|
|
Season.SPRING < Season.WINTER
|
|
with self.assertRaises(TypeError):
|
|
Season.SPRING > 4
|
|
|
|
self.assertNotEqual(Season.SPRING, 1)
|
|
|
|
class Part(Enum):
|
|
SPRING = 1
|
|
CLIP = 2
|
|
BARREL = 3
|
|
|
|
self.assertNotEqual(Season.SPRING, Part.SPRING)
|
|
with self.assertRaises(TypeError):
|
|
Season.SPRING < Part.CLIP
|
|
|
|
def test_enum_duplicates(self):
|
|
class Season(Enum):
|
|
SPRING = 1
|
|
SUMMER = 2
|
|
AUTUMN = FALL = 3
|
|
WINTER = 4
|
|
ANOTHER_SPRING = 1
|
|
lst = list(Season)
|
|
self.assertEqual(
|
|
lst,
|
|
[Season.SPRING, Season.SUMMER,
|
|
Season.AUTUMN, Season.WINTER,
|
|
])
|
|
self.assertIs(Season.FALL, Season.AUTUMN)
|
|
self.assertEqual(Season.FALL.value, 3)
|
|
self.assertEqual(Season.AUTUMN.value, 3)
|
|
self.assertIs(Season(3), Season.AUTUMN)
|
|
self.assertIs(Season(1), Season.SPRING)
|
|
self.assertEqual(Season.FALL.name, 'AUTUMN')
|
|
self.assertEqual(
|
|
[k for k,v in Season.__members__.items() if v.name != k],
|
|
['FALL', 'ANOTHER_SPRING'],
|
|
)
|
|
|
|
def test_duplicate_name(self):
|
|
with self.assertRaises(TypeError):
|
|
class Color(Enum):
|
|
red = 1
|
|
green = 2
|
|
blue = 3
|
|
red = 4
|
|
|
|
with self.assertRaises(TypeError):
|
|
class Color(Enum):
|
|
red = 1
|
|
green = 2
|
|
blue = 3
|
|
def red(self):
|
|
return 'red'
|
|
|
|
with self.assertRaises(TypeError):
|
|
class Color(Enum):
|
|
@property
|
|
def red(self):
|
|
return 'redder'
|
|
red = 1
|
|
green = 2
|
|
blue = 3
|
|
|
|
|
|
def test_enum_with_value_name(self):
|
|
class Huh(Enum):
|
|
name = 1
|
|
value = 2
|
|
self.assertEqual(
|
|
list(Huh),
|
|
[Huh.name, Huh.value],
|
|
)
|
|
self.assertIs(type(Huh.name), Huh)
|
|
self.assertEqual(Huh.name.name, 'name')
|
|
self.assertEqual(Huh.name.value, 1)
|
|
|
|
def test_format_enum(self):
|
|
Season = self.Season
|
|
self.assertEqual('{}'.format(Season.SPRING),
|
|
'{}'.format(str(Season.SPRING)))
|
|
self.assertEqual( '{:}'.format(Season.SPRING),
|
|
'{:}'.format(str(Season.SPRING)))
|
|
self.assertEqual('{:20}'.format(Season.SPRING),
|
|
'{:20}'.format(str(Season.SPRING)))
|
|
self.assertEqual('{:^20}'.format(Season.SPRING),
|
|
'{:^20}'.format(str(Season.SPRING)))
|
|
self.assertEqual('{:>20}'.format(Season.SPRING),
|
|
'{:>20}'.format(str(Season.SPRING)))
|
|
self.assertEqual('{:<20}'.format(Season.SPRING),
|
|
'{:<20}'.format(str(Season.SPRING)))
|
|
|
|
def test_format_enum_custom(self):
|
|
class TestFloat(float, Enum):
|
|
one = 1.0
|
|
two = 2.0
|
|
def __format__(self, spec):
|
|
return 'TestFloat success!'
|
|
self.assertEqual('{}'.format(TestFloat.one), 'TestFloat success!')
|
|
|
|
def assertFormatIsValue(self, spec, member):
|
|
self.assertEqual(spec.format(member), spec.format(member.value))
|
|
|
|
def test_format_enum_date(self):
|
|
Holiday = self.Holiday
|
|
self.assertFormatIsValue('{}', Holiday.IDES_OF_MARCH)
|
|
self.assertFormatIsValue('{:}', Holiday.IDES_OF_MARCH)
|
|
self.assertFormatIsValue('{:20}', Holiday.IDES_OF_MARCH)
|
|
self.assertFormatIsValue('{:^20}', Holiday.IDES_OF_MARCH)
|
|
self.assertFormatIsValue('{:>20}', Holiday.IDES_OF_MARCH)
|
|
self.assertFormatIsValue('{:<20}', Holiday.IDES_OF_MARCH)
|
|
self.assertFormatIsValue('{:%Y %m}', Holiday.IDES_OF_MARCH)
|
|
self.assertFormatIsValue('{:%Y %m %M:00}', Holiday.IDES_OF_MARCH)
|
|
|
|
def test_format_enum_float(self):
|
|
Konstants = self.Konstants
|
|
self.assertFormatIsValue('{}', Konstants.TAU)
|
|
self.assertFormatIsValue('{:}', Konstants.TAU)
|
|
self.assertFormatIsValue('{:20}', Konstants.TAU)
|
|
self.assertFormatIsValue('{:^20}', Konstants.TAU)
|
|
self.assertFormatIsValue('{:>20}', Konstants.TAU)
|
|
self.assertFormatIsValue('{:<20}', Konstants.TAU)
|
|
self.assertFormatIsValue('{:n}', Konstants.TAU)
|
|
self.assertFormatIsValue('{:5.2}', Konstants.TAU)
|
|
self.assertFormatIsValue('{:f}', Konstants.TAU)
|
|
|
|
def test_format_enum_int(self):
|
|
Grades = self.Grades
|
|
self.assertFormatIsValue('{}', Grades.C)
|
|
self.assertFormatIsValue('{:}', Grades.C)
|
|
self.assertFormatIsValue('{:20}', Grades.C)
|
|
self.assertFormatIsValue('{:^20}', Grades.C)
|
|
self.assertFormatIsValue('{:>20}', Grades.C)
|
|
self.assertFormatIsValue('{:<20}', Grades.C)
|
|
self.assertFormatIsValue('{:+}', Grades.C)
|
|
self.assertFormatIsValue('{:08X}', Grades.C)
|
|
self.assertFormatIsValue('{:b}', Grades.C)
|
|
|
|
def test_format_enum_str(self):
|
|
Directional = self.Directional
|
|
self.assertFormatIsValue('{}', Directional.WEST)
|
|
self.assertFormatIsValue('{:}', Directional.WEST)
|
|
self.assertFormatIsValue('{:20}', Directional.WEST)
|
|
self.assertFormatIsValue('{:^20}', Directional.WEST)
|
|
self.assertFormatIsValue('{:>20}', Directional.WEST)
|
|
self.assertFormatIsValue('{:<20}', Directional.WEST)
|
|
|
|
def test_hash(self):
|
|
Season = self.Season
|
|
dates = {}
|
|
dates[Season.WINTER] = '1225'
|
|
dates[Season.SPRING] = '0315'
|
|
dates[Season.SUMMER] = '0704'
|
|
dates[Season.AUTUMN] = '1031'
|
|
self.assertEqual(dates[Season.AUTUMN], '1031')
|
|
|
|
def test_intenum_from_scratch(self):
|
|
class phy(int, Enum):
|
|
pi = 3
|
|
tau = 2 * pi
|
|
self.assertTrue(phy.pi < phy.tau)
|
|
|
|
def test_intenum_inherited(self):
|
|
class IntEnum(int, Enum):
|
|
pass
|
|
class phy(IntEnum):
|
|
pi = 3
|
|
tau = 2 * pi
|
|
self.assertTrue(phy.pi < phy.tau)
|
|
|
|
def test_floatenum_from_scratch(self):
|
|
class phy(float, Enum):
|
|
pi = 3.1415926
|
|
tau = 2 * pi
|
|
self.assertTrue(phy.pi < phy.tau)
|
|
|
|
def test_floatenum_inherited(self):
|
|
class FloatEnum(float, Enum):
|
|
pass
|
|
class phy(FloatEnum):
|
|
pi = 3.1415926
|
|
tau = 2 * pi
|
|
self.assertTrue(phy.pi < phy.tau)
|
|
|
|
def test_strenum_from_scratch(self):
|
|
class phy(str, Enum):
|
|
pi = 'Pi'
|
|
tau = 'Tau'
|
|
self.assertTrue(phy.pi < phy.tau)
|
|
|
|
def test_strenum_inherited(self):
|
|
class StrEnum(str, Enum):
|
|
pass
|
|
class phy(StrEnum):
|
|
pi = 'Pi'
|
|
tau = 'Tau'
|
|
self.assertTrue(phy.pi < phy.tau)
|
|
|
|
|
|
def test_intenum(self):
|
|
class WeekDay(IntEnum):
|
|
SUNDAY = 1
|
|
MONDAY = 2
|
|
TUESDAY = 3
|
|
WEDNESDAY = 4
|
|
THURSDAY = 5
|
|
FRIDAY = 6
|
|
SATURDAY = 7
|
|
|
|
self.assertEqual(['a', 'b', 'c'][WeekDay.MONDAY], 'c')
|
|
self.assertEqual([i for i in range(WeekDay.TUESDAY)], [0, 1, 2])
|
|
|
|
lst = list(WeekDay)
|
|
self.assertEqual(len(lst), len(WeekDay))
|
|
self.assertEqual(len(WeekDay), 7)
|
|
target = 'SUNDAY MONDAY TUESDAY WEDNESDAY THURSDAY FRIDAY SATURDAY'
|
|
target = target.split()
|
|
for i, weekday in enumerate(target, 1):
|
|
e = WeekDay(i)
|
|
self.assertEqual(e, i)
|
|
self.assertEqual(int(e), i)
|
|
self.assertEqual(e.name, weekday)
|
|
self.assertIn(e, WeekDay)
|
|
self.assertEqual(lst.index(e)+1, i)
|
|
self.assertTrue(0 < e < 8)
|
|
self.assertIs(type(e), WeekDay)
|
|
self.assertIsInstance(e, int)
|
|
self.assertIsInstance(e, Enum)
|
|
|
|
def test_intenum_duplicates(self):
|
|
class WeekDay(IntEnum):
|
|
SUNDAY = 1
|
|
MONDAY = 2
|
|
TUESDAY = TEUSDAY = 3
|
|
WEDNESDAY = 4
|
|
THURSDAY = 5
|
|
FRIDAY = 6
|
|
SATURDAY = 7
|
|
self.assertIs(WeekDay.TEUSDAY, WeekDay.TUESDAY)
|
|
self.assertEqual(WeekDay(3).name, 'TUESDAY')
|
|
self.assertEqual([k for k,v in WeekDay.__members__.items()
|
|
if v.name != k], ['TEUSDAY', ])
|
|
|
|
def test_intenum_from_bytes(self):
|
|
self.assertIs(IntStooges.from_bytes(b'\x00\x03', 'big'), IntStooges.MOE)
|
|
with self.assertRaises(ValueError):
|
|
IntStooges.from_bytes(b'\x00\x05', 'big')
|
|
|
|
def test_floatenum_fromhex(self):
|
|
h = float.hex(FloatStooges.MOE.value)
|
|
self.assertIs(FloatStooges.fromhex(h), FloatStooges.MOE)
|
|
h = float.hex(FloatStooges.MOE.value + 0.01)
|
|
with self.assertRaises(ValueError):
|
|
FloatStooges.fromhex(h)
|
|
|
|
def test_pickle_enum(self):
|
|
if isinstance(Stooges, Exception):
|
|
raise Stooges
|
|
test_pickle_dump_load(self.assertIs, Stooges.CURLY)
|
|
test_pickle_dump_load(self.assertIs, Stooges)
|
|
|
|
def test_pickle_int(self):
|
|
if isinstance(IntStooges, Exception):
|
|
raise IntStooges
|
|
test_pickle_dump_load(self.assertIs, IntStooges.CURLY)
|
|
test_pickle_dump_load(self.assertIs, IntStooges)
|
|
|
|
def test_pickle_float(self):
|
|
if isinstance(FloatStooges, Exception):
|
|
raise FloatStooges
|
|
test_pickle_dump_load(self.assertIs, FloatStooges.CURLY)
|
|
test_pickle_dump_load(self.assertIs, FloatStooges)
|
|
|
|
def test_pickle_enum_function(self):
|
|
if isinstance(Answer, Exception):
|
|
raise Answer
|
|
test_pickle_dump_load(self.assertIs, Answer.him)
|
|
test_pickle_dump_load(self.assertIs, Answer)
|
|
|
|
def test_pickle_enum_function_with_module(self):
|
|
if isinstance(Question, Exception):
|
|
raise Question
|
|
test_pickle_dump_load(self.assertIs, Question.who)
|
|
test_pickle_dump_load(self.assertIs, Question)
|
|
|
|
def test_enum_function_with_qualname(self):
|
|
if isinstance(Theory, Exception):
|
|
raise Theory
|
|
self.assertEqual(Theory.__qualname__, 'spanish_inquisition')
|
|
|
|
def test_class_nested_enum_and_pickle_protocol_four(self):
|
|
# would normally just have this directly in the class namespace
|
|
class NestedEnum(Enum):
|
|
twigs = 'common'
|
|
shiny = 'rare'
|
|
|
|
self.__class__.NestedEnum = NestedEnum
|
|
self.NestedEnum.__qualname__ = '%s.NestedEnum' % self.__class__.__name__
|
|
test_pickle_dump_load(self.assertIs, self.NestedEnum.twigs)
|
|
|
|
def test_pickle_by_name(self):
|
|
class ReplaceGlobalInt(IntEnum):
|
|
ONE = 1
|
|
TWO = 2
|
|
ReplaceGlobalInt.__reduce_ex__ = enum._reduce_ex_by_name
|
|
for proto in range(HIGHEST_PROTOCOL):
|
|
self.assertEqual(ReplaceGlobalInt.TWO.__reduce_ex__(proto), 'TWO')
|
|
|
|
def test_exploding_pickle(self):
|
|
BadPickle = Enum(
|
|
'BadPickle', 'dill sweet bread-n-butter', module=__name__)
|
|
globals()['BadPickle'] = BadPickle
|
|
# now break BadPickle to test exception raising
|
|
enum._make_class_unpicklable(BadPickle)
|
|
test_pickle_exception(self.assertRaises, TypeError, BadPickle.dill)
|
|
test_pickle_exception(self.assertRaises, PicklingError, BadPickle)
|
|
|
|
def test_string_enum(self):
|
|
class SkillLevel(str, Enum):
|
|
master = 'what is the sound of one hand clapping?'
|
|
journeyman = 'why did the chicken cross the road?'
|
|
apprentice = 'knock, knock!'
|
|
self.assertEqual(SkillLevel.apprentice, 'knock, knock!')
|
|
|
|
def test_getattr_getitem(self):
|
|
class Period(Enum):
|
|
morning = 1
|
|
noon = 2
|
|
evening = 3
|
|
night = 4
|
|
self.assertIs(Period(2), Period.noon)
|
|
self.assertIs(getattr(Period, 'night'), Period.night)
|
|
self.assertIs(Period['morning'], Period.morning)
|
|
|
|
def test_getattr_dunder(self):
|
|
Season = self.Season
|
|
self.assertTrue(getattr(Season, '__eq__'))
|
|
|
|
def test_iteration_order(self):
|
|
class Season(Enum):
|
|
SUMMER = 2
|
|
WINTER = 4
|
|
AUTUMN = 3
|
|
SPRING = 1
|
|
self.assertEqual(
|
|
list(Season),
|
|
[Season.SUMMER, Season.WINTER, Season.AUTUMN, Season.SPRING],
|
|
)
|
|
|
|
def test_reversed_iteration_order(self):
|
|
self.assertEqual(
|
|
list(reversed(self.Season)),
|
|
[self.Season.WINTER, self.Season.AUTUMN, self.Season.SUMMER,
|
|
self.Season.SPRING]
|
|
)
|
|
|
|
def test_programatic_function_string(self):
|
|
SummerMonth = Enum('SummerMonth', 'june july august')
|
|
lst = list(SummerMonth)
|
|
self.assertEqual(len(lst), len(SummerMonth))
|
|
self.assertEqual(len(SummerMonth), 3, SummerMonth)
|
|
self.assertEqual(
|
|
[SummerMonth.june, SummerMonth.july, SummerMonth.august],
|
|
lst,
|
|
)
|
|
for i, month in enumerate('june july august'.split(), 1):
|
|
e = SummerMonth(i)
|
|
self.assertEqual(int(e.value), i)
|
|
self.assertNotEqual(e, i)
|
|
self.assertEqual(e.name, month)
|
|
self.assertIn(e, SummerMonth)
|
|
self.assertIs(type(e), SummerMonth)
|
|
|
|
def test_programatic_function_string_with_start(self):
|
|
SummerMonth = Enum('SummerMonth', 'june july august', start=10)
|
|
lst = list(SummerMonth)
|
|
self.assertEqual(len(lst), len(SummerMonth))
|
|
self.assertEqual(len(SummerMonth), 3, SummerMonth)
|
|
self.assertEqual(
|
|
[SummerMonth.june, SummerMonth.july, SummerMonth.august],
|
|
lst,
|
|
)
|
|
for i, month in enumerate('june july august'.split(), 10):
|
|
e = SummerMonth(i)
|
|
self.assertEqual(int(e.value), i)
|
|
self.assertNotEqual(e, i)
|
|
self.assertEqual(e.name, month)
|
|
self.assertIn(e, SummerMonth)
|
|
self.assertIs(type(e), SummerMonth)
|
|
|
|
def test_programatic_function_string_list(self):
|
|
SummerMonth = Enum('SummerMonth', ['june', 'july', 'august'])
|
|
lst = list(SummerMonth)
|
|
self.assertEqual(len(lst), len(SummerMonth))
|
|
self.assertEqual(len(SummerMonth), 3, SummerMonth)
|
|
self.assertEqual(
|
|
[SummerMonth.june, SummerMonth.july, SummerMonth.august],
|
|
lst,
|
|
)
|
|
for i, month in enumerate('june july august'.split(), 1):
|
|
e = SummerMonth(i)
|
|
self.assertEqual(int(e.value), i)
|
|
self.assertNotEqual(e, i)
|
|
self.assertEqual(e.name, month)
|
|
self.assertIn(e, SummerMonth)
|
|
self.assertIs(type(e), SummerMonth)
|
|
|
|
def test_programatic_function_string_list_with_start(self):
|
|
SummerMonth = Enum('SummerMonth', ['june', 'july', 'august'], start=20)
|
|
lst = list(SummerMonth)
|
|
self.assertEqual(len(lst), len(SummerMonth))
|
|
self.assertEqual(len(SummerMonth), 3, SummerMonth)
|
|
self.assertEqual(
|
|
[SummerMonth.june, SummerMonth.july, SummerMonth.august],
|
|
lst,
|
|
)
|
|
for i, month in enumerate('june july august'.split(), 20):
|
|
e = SummerMonth(i)
|
|
self.assertEqual(int(e.value), i)
|
|
self.assertNotEqual(e, i)
|
|
self.assertEqual(e.name, month)
|
|
self.assertIn(e, SummerMonth)
|
|
self.assertIs(type(e), SummerMonth)
|
|
|
|
def test_programatic_function_iterable(self):
|
|
SummerMonth = Enum(
|
|
'SummerMonth',
|
|
(('june', 1), ('july', 2), ('august', 3))
|
|
)
|
|
lst = list(SummerMonth)
|
|
self.assertEqual(len(lst), len(SummerMonth))
|
|
self.assertEqual(len(SummerMonth), 3, SummerMonth)
|
|
self.assertEqual(
|
|
[SummerMonth.june, SummerMonth.july, SummerMonth.august],
|
|
lst,
|
|
)
|
|
for i, month in enumerate('june july august'.split(), 1):
|
|
e = SummerMonth(i)
|
|
self.assertEqual(int(e.value), i)
|
|
self.assertNotEqual(e, i)
|
|
self.assertEqual(e.name, month)
|
|
self.assertIn(e, SummerMonth)
|
|
self.assertIs(type(e), SummerMonth)
|
|
|
|
def test_programatic_function_from_dict(self):
|
|
SummerMonth = Enum(
|
|
'SummerMonth',
|
|
OrderedDict((('june', 1), ('july', 2), ('august', 3)))
|
|
)
|
|
lst = list(SummerMonth)
|
|
self.assertEqual(len(lst), len(SummerMonth))
|
|
self.assertEqual(len(SummerMonth), 3, SummerMonth)
|
|
self.assertEqual(
|
|
[SummerMonth.june, SummerMonth.july, SummerMonth.august],
|
|
lst,
|
|
)
|
|
for i, month in enumerate('june july august'.split(), 1):
|
|
e = SummerMonth(i)
|
|
self.assertEqual(int(e.value), i)
|
|
self.assertNotEqual(e, i)
|
|
self.assertEqual(e.name, month)
|
|
self.assertIn(e, SummerMonth)
|
|
self.assertIs(type(e), SummerMonth)
|
|
|
|
def test_programatic_function_type(self):
|
|
SummerMonth = Enum('SummerMonth', 'june july august', type=int)
|
|
lst = list(SummerMonth)
|
|
self.assertEqual(len(lst), len(SummerMonth))
|
|
self.assertEqual(len(SummerMonth), 3, SummerMonth)
|
|
self.assertEqual(
|
|
[SummerMonth.june, SummerMonth.july, SummerMonth.august],
|
|
lst,
|
|
)
|
|
for i, month in enumerate('june july august'.split(), 1):
|
|
e = SummerMonth(i)
|
|
self.assertEqual(e, i)
|
|
self.assertEqual(e.name, month)
|
|
self.assertIn(e, SummerMonth)
|
|
self.assertIs(type(e), SummerMonth)
|
|
|
|
def test_programatic_function_type_with_start(self):
|
|
SummerMonth = Enum('SummerMonth', 'june july august', type=int, start=30)
|
|
lst = list(SummerMonth)
|
|
self.assertEqual(len(lst), len(SummerMonth))
|
|
self.assertEqual(len(SummerMonth), 3, SummerMonth)
|
|
self.assertEqual(
|
|
[SummerMonth.june, SummerMonth.july, SummerMonth.august],
|
|
lst,
|
|
)
|
|
for i, month in enumerate('june july august'.split(), 30):
|
|
e = SummerMonth(i)
|
|
self.assertEqual(e, i)
|
|
self.assertEqual(e.name, month)
|
|
self.assertIn(e, SummerMonth)
|
|
self.assertIs(type(e), SummerMonth)
|
|
|
|
def test_programatic_function_type_from_subclass(self):
|
|
SummerMonth = IntEnum('SummerMonth', 'june july august')
|
|
lst = list(SummerMonth)
|
|
self.assertEqual(len(lst), len(SummerMonth))
|
|
self.assertEqual(len(SummerMonth), 3, SummerMonth)
|
|
self.assertEqual(
|
|
[SummerMonth.june, SummerMonth.july, SummerMonth.august],
|
|
lst,
|
|
)
|
|
for i, month in enumerate('june july august'.split(), 1):
|
|
e = SummerMonth(i)
|
|
self.assertEqual(e, i)
|
|
self.assertEqual(e.name, month)
|
|
self.assertIn(e, SummerMonth)
|
|
self.assertIs(type(e), SummerMonth)
|
|
|
|
def test_programatic_function_type_from_subclass_with_start(self):
|
|
SummerMonth = IntEnum('SummerMonth', 'june july august', start=40)
|
|
lst = list(SummerMonth)
|
|
self.assertEqual(len(lst), len(SummerMonth))
|
|
self.assertEqual(len(SummerMonth), 3, SummerMonth)
|
|
self.assertEqual(
|
|
[SummerMonth.june, SummerMonth.july, SummerMonth.august],
|
|
lst,
|
|
)
|
|
for i, month in enumerate('june july august'.split(), 40):
|
|
e = SummerMonth(i)
|
|
self.assertEqual(e, i)
|
|
self.assertEqual(e.name, month)
|
|
self.assertIn(e, SummerMonth)
|
|
self.assertIs(type(e), SummerMonth)
|
|
|
|
def test_subclassing(self):
|
|
if isinstance(Name, Exception):
|
|
raise Name
|
|
self.assertEqual(Name.BDFL, 'Guido van Rossum')
|
|
self.assertTrue(Name.BDFL, Name('Guido van Rossum'))
|
|
self.assertIs(Name.BDFL, getattr(Name, 'BDFL'))
|
|
test_pickle_dump_load(self.assertIs, Name.BDFL)
|
|
|
|
def test_extending(self):
|
|
class Color(Enum):
|
|
red = 1
|
|
green = 2
|
|
blue = 3
|
|
with self.assertRaises(TypeError):
|
|
class MoreColor(Color):
|
|
cyan = 4
|
|
magenta = 5
|
|
yellow = 6
|
|
|
|
def test_exclude_methods(self):
|
|
class whatever(Enum):
|
|
this = 'that'
|
|
these = 'those'
|
|
def really(self):
|
|
return 'no, not %s' % self.value
|
|
self.assertIsNot(type(whatever.really), whatever)
|
|
self.assertEqual(whatever.this.really(), 'no, not that')
|
|
|
|
def test_wrong_inheritance_order(self):
|
|
with self.assertRaises(TypeError):
|
|
class Wrong(Enum, str):
|
|
NotHere = 'error before this point'
|
|
|
|
def test_intenum_transitivity(self):
|
|
class number(IntEnum):
|
|
one = 1
|
|
two = 2
|
|
three = 3
|
|
class numero(IntEnum):
|
|
uno = 1
|
|
dos = 2
|
|
tres = 3
|
|
self.assertEqual(number.one, numero.uno)
|
|
self.assertEqual(number.two, numero.dos)
|
|
self.assertEqual(number.three, numero.tres)
|
|
|
|
def test_wrong_enum_in_call(self):
|
|
class Monochrome(Enum):
|
|
black = 0
|
|
white = 1
|
|
class Gender(Enum):
|
|
male = 0
|
|
female = 1
|
|
self.assertRaises(ValueError, Monochrome, Gender.male)
|
|
|
|
def test_wrong_enum_in_mixed_call(self):
|
|
class Monochrome(IntEnum):
|
|
black = 0
|
|
white = 1
|
|
class Gender(Enum):
|
|
male = 0
|
|
female = 1
|
|
self.assertRaises(ValueError, Monochrome, Gender.male)
|
|
|
|
def test_mixed_enum_in_call_1(self):
|
|
class Monochrome(IntEnum):
|
|
black = 0
|
|
white = 1
|
|
class Gender(IntEnum):
|
|
male = 0
|
|
female = 1
|
|
self.assertIs(Monochrome(Gender.female), Monochrome.white)
|
|
|
|
def test_mixed_enum_in_call_2(self):
|
|
class Monochrome(Enum):
|
|
black = 0
|
|
white = 1
|
|
class Gender(IntEnum):
|
|
male = 0
|
|
female = 1
|
|
self.assertIs(Monochrome(Gender.male), Monochrome.black)
|
|
|
|
def test_flufl_enum(self):
|
|
class Fluflnum(Enum):
|
|
def __int__(self):
|
|
return int(self.value)
|
|
class MailManOptions(Fluflnum):
|
|
option1 = 1
|
|
option2 = 2
|
|
option3 = 3
|
|
self.assertEqual(int(MailManOptions.option1), 1)
|
|
|
|
def test_introspection(self):
|
|
class Number(IntEnum):
|
|
one = 100
|
|
two = 200
|
|
self.assertIs(Number.one._member_type_, int)
|
|
self.assertIs(Number._member_type_, int)
|
|
class String(str, Enum):
|
|
yarn = 'soft'
|
|
rope = 'rough'
|
|
wire = 'hard'
|
|
self.assertIs(String.yarn._member_type_, str)
|
|
self.assertIs(String._member_type_, str)
|
|
class Plain(Enum):
|
|
vanilla = 'white'
|
|
one = 1
|
|
self.assertIs(Plain.vanilla._member_type_, object)
|
|
self.assertIs(Plain._member_type_, object)
|
|
|
|
def test_no_such_enum_member(self):
|
|
class Color(Enum):
|
|
red = 1
|
|
green = 2
|
|
blue = 3
|
|
with self.assertRaises(ValueError):
|
|
Color(4)
|
|
with self.assertRaises(KeyError):
|
|
Color['chartreuse']
|
|
|
|
def test_new_repr(self):
|
|
class Color(Enum):
|
|
red = 1
|
|
green = 2
|
|
blue = 3
|
|
def __repr__(self):
|
|
return "don't you just love shades of %s?" % self.name
|
|
self.assertEqual(
|
|
repr(Color.blue),
|
|
"don't you just love shades of blue?",
|
|
)
|
|
|
|
def test_inherited_repr(self):
|
|
class MyEnum(Enum):
|
|
def __repr__(self):
|
|
return "My name is %s." % self.name
|
|
class MyIntEnum(int, MyEnum):
|
|
this = 1
|
|
that = 2
|
|
theother = 3
|
|
self.assertEqual(repr(MyIntEnum.that), "My name is that.")
|
|
|
|
def test_multiple_mixin_mro(self):
|
|
class auto_enum(type(Enum)):
|
|
def __new__(metacls, cls, bases, classdict):
|
|
temp = type(classdict)()
|
|
names = set(classdict._member_names)
|
|
i = 0
|
|
for k in classdict._member_names:
|
|
v = classdict[k]
|
|
if v is Ellipsis:
|
|
v = i
|
|
else:
|
|
i = v
|
|
i += 1
|
|
temp[k] = v
|
|
for k, v in classdict.items():
|
|
if k not in names:
|
|
temp[k] = v
|
|
return super(auto_enum, metacls).__new__(
|
|
metacls, cls, bases, temp)
|
|
|
|
class AutoNumberedEnum(Enum, metaclass=auto_enum):
|
|
pass
|
|
|
|
class AutoIntEnum(IntEnum, metaclass=auto_enum):
|
|
pass
|
|
|
|
class TestAutoNumber(AutoNumberedEnum):
|
|
a = ...
|
|
b = 3
|
|
c = ...
|
|
|
|
class TestAutoInt(AutoIntEnum):
|
|
a = ...
|
|
b = 3
|
|
c = ...
|
|
|
|
def test_subclasses_with_getnewargs(self):
|
|
class NamedInt(int):
|
|
__qualname__ = 'NamedInt' # needed for pickle protocol 4
|
|
def __new__(cls, *args):
|
|
_args = args
|
|
name, *args = args
|
|
if len(args) == 0:
|
|
raise TypeError("name and value must be specified")
|
|
self = int.__new__(cls, *args)
|
|
self._intname = name
|
|
self._args = _args
|
|
return self
|
|
def __getnewargs__(self):
|
|
return self._args
|
|
@property
|
|
def __name__(self):
|
|
return self._intname
|
|
def __repr__(self):
|
|
# repr() is updated to include the name and type info
|
|
return "{}({!r}, {})".format(type(self).__name__,
|
|
self.__name__,
|
|
int.__repr__(self))
|
|
def __str__(self):
|
|
# str() is unchanged, even if it relies on the repr() fallback
|
|
base = int
|
|
base_str = base.__str__
|
|
if base_str.__objclass__ is object:
|
|
return base.__repr__(self)
|
|
return base_str(self)
|
|
# for simplicity, we only define one operator that
|
|
# propagates expressions
|
|
def __add__(self, other):
|
|
temp = int(self) + int( other)
|
|
if isinstance(self, NamedInt) and isinstance(other, NamedInt):
|
|
return NamedInt(
|
|
'({0} + {1})'.format(self.__name__, other.__name__),
|
|
temp )
|
|
else:
|
|
return temp
|
|
|
|
class NEI(NamedInt, Enum):
|
|
__qualname__ = 'NEI' # needed for pickle protocol 4
|
|
x = ('the-x', 1)
|
|
y = ('the-y', 2)
|
|
|
|
|
|
self.assertIs(NEI.__new__, Enum.__new__)
|
|
self.assertEqual(repr(NEI.x + NEI.y), "NamedInt('(the-x + the-y)', 3)")
|
|
globals()['NamedInt'] = NamedInt
|
|
globals()['NEI'] = NEI
|
|
NI5 = NamedInt('test', 5)
|
|
self.assertEqual(NI5, 5)
|
|
test_pickle_dump_load(self.assertEqual, NI5, 5)
|
|
self.assertEqual(NEI.y.value, 2)
|
|
test_pickle_dump_load(self.assertIs, NEI.y)
|
|
test_pickle_dump_load(self.assertIs, NEI)
|
|
|
|
def test_subclasses_with_getnewargs_ex(self):
|
|
class NamedInt(int):
|
|
__qualname__ = 'NamedInt' # needed for pickle protocol 4
|
|
def __new__(cls, *args):
|
|
_args = args
|
|
name, *args = args
|
|
if len(args) == 0:
|
|
raise TypeError("name and value must be specified")
|
|
self = int.__new__(cls, *args)
|
|
self._intname = name
|
|
self._args = _args
|
|
return self
|
|
def __getnewargs_ex__(self):
|
|
return self._args, {}
|
|
@property
|
|
def __name__(self):
|
|
return self._intname
|
|
def __repr__(self):
|
|
# repr() is updated to include the name and type info
|
|
return "{}({!r}, {})".format(type(self).__name__,
|
|
self.__name__,
|
|
int.__repr__(self))
|
|
def __str__(self):
|
|
# str() is unchanged, even if it relies on the repr() fallback
|
|
base = int
|
|
base_str = base.__str__
|
|
if base_str.__objclass__ is object:
|
|
return base.__repr__(self)
|
|
return base_str(self)
|
|
# for simplicity, we only define one operator that
|
|
# propagates expressions
|
|
def __add__(self, other):
|
|
temp = int(self) + int( other)
|
|
if isinstance(self, NamedInt) and isinstance(other, NamedInt):
|
|
return NamedInt(
|
|
'({0} + {1})'.format(self.__name__, other.__name__),
|
|
temp )
|
|
else:
|
|
return temp
|
|
|
|
class NEI(NamedInt, Enum):
|
|
__qualname__ = 'NEI' # needed for pickle protocol 4
|
|
x = ('the-x', 1)
|
|
y = ('the-y', 2)
|
|
|
|
|
|
self.assertIs(NEI.__new__, Enum.__new__)
|
|
self.assertEqual(repr(NEI.x + NEI.y), "NamedInt('(the-x + the-y)', 3)")
|
|
globals()['NamedInt'] = NamedInt
|
|
globals()['NEI'] = NEI
|
|
NI5 = NamedInt('test', 5)
|
|
self.assertEqual(NI5, 5)
|
|
test_pickle_dump_load(self.assertEqual, NI5, 5)
|
|
self.assertEqual(NEI.y.value, 2)
|
|
test_pickle_dump_load(self.assertIs, NEI.y)
|
|
test_pickle_dump_load(self.assertIs, NEI)
|
|
|
|
def test_subclasses_with_reduce(self):
|
|
class NamedInt(int):
|
|
__qualname__ = 'NamedInt' # needed for pickle protocol 4
|
|
def __new__(cls, *args):
|
|
_args = args
|
|
name, *args = args
|
|
if len(args) == 0:
|
|
raise TypeError("name and value must be specified")
|
|
self = int.__new__(cls, *args)
|
|
self._intname = name
|
|
self._args = _args
|
|
return self
|
|
def __reduce__(self):
|
|
return self.__class__, self._args
|
|
@property
|
|
def __name__(self):
|
|
return self._intname
|
|
def __repr__(self):
|
|
# repr() is updated to include the name and type info
|
|
return "{}({!r}, {})".format(type(self).__name__,
|
|
self.__name__,
|
|
int.__repr__(self))
|
|
def __str__(self):
|
|
# str() is unchanged, even if it relies on the repr() fallback
|
|
base = int
|
|
base_str = base.__str__
|
|
if base_str.__objclass__ is object:
|
|
return base.__repr__(self)
|
|
return base_str(self)
|
|
# for simplicity, we only define one operator that
|
|
# propagates expressions
|
|
def __add__(self, other):
|
|
temp = int(self) + int( other)
|
|
if isinstance(self, NamedInt) and isinstance(other, NamedInt):
|
|
return NamedInt(
|
|
'({0} + {1})'.format(self.__name__, other.__name__),
|
|
temp )
|
|
else:
|
|
return temp
|
|
|
|
class NEI(NamedInt, Enum):
|
|
__qualname__ = 'NEI' # needed for pickle protocol 4
|
|
x = ('the-x', 1)
|
|
y = ('the-y', 2)
|
|
|
|
|
|
self.assertIs(NEI.__new__, Enum.__new__)
|
|
self.assertEqual(repr(NEI.x + NEI.y), "NamedInt('(the-x + the-y)', 3)")
|
|
globals()['NamedInt'] = NamedInt
|
|
globals()['NEI'] = NEI
|
|
NI5 = NamedInt('test', 5)
|
|
self.assertEqual(NI5, 5)
|
|
test_pickle_dump_load(self.assertEqual, NI5, 5)
|
|
self.assertEqual(NEI.y.value, 2)
|
|
test_pickle_dump_load(self.assertIs, NEI.y)
|
|
test_pickle_dump_load(self.assertIs, NEI)
|
|
|
|
def test_subclasses_with_reduce_ex(self):
|
|
class NamedInt(int):
|
|
__qualname__ = 'NamedInt' # needed for pickle protocol 4
|
|
def __new__(cls, *args):
|
|
_args = args
|
|
name, *args = args
|
|
if len(args) == 0:
|
|
raise TypeError("name and value must be specified")
|
|
self = int.__new__(cls, *args)
|
|
self._intname = name
|
|
self._args = _args
|
|
return self
|
|
def __reduce_ex__(self, proto):
|
|
return self.__class__, self._args
|
|
@property
|
|
def __name__(self):
|
|
return self._intname
|
|
def __repr__(self):
|
|
# repr() is updated to include the name and type info
|
|
return "{}({!r}, {})".format(type(self).__name__,
|
|
self.__name__,
|
|
int.__repr__(self))
|
|
def __str__(self):
|
|
# str() is unchanged, even if it relies on the repr() fallback
|
|
base = int
|
|
base_str = base.__str__
|
|
if base_str.__objclass__ is object:
|
|
return base.__repr__(self)
|
|
return base_str(self)
|
|
# for simplicity, we only define one operator that
|
|
# propagates expressions
|
|
def __add__(self, other):
|
|
temp = int(self) + int( other)
|
|
if isinstance(self, NamedInt) and isinstance(other, NamedInt):
|
|
return NamedInt(
|
|
'({0} + {1})'.format(self.__name__, other.__name__),
|
|
temp )
|
|
else:
|
|
return temp
|
|
|
|
class NEI(NamedInt, Enum):
|
|
__qualname__ = 'NEI' # needed for pickle protocol 4
|
|
x = ('the-x', 1)
|
|
y = ('the-y', 2)
|
|
|
|
|
|
self.assertIs(NEI.__new__, Enum.__new__)
|
|
self.assertEqual(repr(NEI.x + NEI.y), "NamedInt('(the-x + the-y)', 3)")
|
|
globals()['NamedInt'] = NamedInt
|
|
globals()['NEI'] = NEI
|
|
NI5 = NamedInt('test', 5)
|
|
self.assertEqual(NI5, 5)
|
|
test_pickle_dump_load(self.assertEqual, NI5, 5)
|
|
self.assertEqual(NEI.y.value, 2)
|
|
test_pickle_dump_load(self.assertIs, NEI.y)
|
|
test_pickle_dump_load(self.assertIs, NEI)
|
|
|
|
def test_subclasses_without_direct_pickle_support(self):
|
|
class NamedInt(int):
|
|
__qualname__ = 'NamedInt'
|
|
def __new__(cls, *args):
|
|
_args = args
|
|
name, *args = args
|
|
if len(args) == 0:
|
|
raise TypeError("name and value must be specified")
|
|
self = int.__new__(cls, *args)
|
|
self._intname = name
|
|
self._args = _args
|
|
return self
|
|
@property
|
|
def __name__(self):
|
|
return self._intname
|
|
def __repr__(self):
|
|
# repr() is updated to include the name and type info
|
|
return "{}({!r}, {})".format(type(self).__name__,
|
|
self.__name__,
|
|
int.__repr__(self))
|
|
def __str__(self):
|
|
# str() is unchanged, even if it relies on the repr() fallback
|
|
base = int
|
|
base_str = base.__str__
|
|
if base_str.__objclass__ is object:
|
|
return base.__repr__(self)
|
|
return base_str(self)
|
|
# for simplicity, we only define one operator that
|
|
# propagates expressions
|
|
def __add__(self, other):
|
|
temp = int(self) + int( other)
|
|
if isinstance(self, NamedInt) and isinstance(other, NamedInt):
|
|
return NamedInt(
|
|
'({0} + {1})'.format(self.__name__, other.__name__),
|
|
temp )
|
|
else:
|
|
return temp
|
|
|
|
class NEI(NamedInt, Enum):
|
|
__qualname__ = 'NEI'
|
|
x = ('the-x', 1)
|
|
y = ('the-y', 2)
|
|
|
|
self.assertIs(NEI.__new__, Enum.__new__)
|
|
self.assertEqual(repr(NEI.x + NEI.y), "NamedInt('(the-x + the-y)', 3)")
|
|
globals()['NamedInt'] = NamedInt
|
|
globals()['NEI'] = NEI
|
|
NI5 = NamedInt('test', 5)
|
|
self.assertEqual(NI5, 5)
|
|
self.assertEqual(NEI.y.value, 2)
|
|
test_pickle_exception(self.assertRaises, TypeError, NEI.x)
|
|
test_pickle_exception(self.assertRaises, PicklingError, NEI)
|
|
|
|
def test_subclasses_without_direct_pickle_support_using_name(self):
|
|
class NamedInt(int):
|
|
__qualname__ = 'NamedInt'
|
|
def __new__(cls, *args):
|
|
_args = args
|
|
name, *args = args
|
|
if len(args) == 0:
|
|
raise TypeError("name and value must be specified")
|
|
self = int.__new__(cls, *args)
|
|
self._intname = name
|
|
self._args = _args
|
|
return self
|
|
@property
|
|
def __name__(self):
|
|
return self._intname
|
|
def __repr__(self):
|
|
# repr() is updated to include the name and type info
|
|
return "{}({!r}, {})".format(type(self).__name__,
|
|
self.__name__,
|
|
int.__repr__(self))
|
|
def __str__(self):
|
|
# str() is unchanged, even if it relies on the repr() fallback
|
|
base = int
|
|
base_str = base.__str__
|
|
if base_str.__objclass__ is object:
|
|
return base.__repr__(self)
|
|
return base_str(self)
|
|
# for simplicity, we only define one operator that
|
|
# propagates expressions
|
|
def __add__(self, other):
|
|
temp = int(self) + int( other)
|
|
if isinstance(self, NamedInt) and isinstance(other, NamedInt):
|
|
return NamedInt(
|
|
'({0} + {1})'.format(self.__name__, other.__name__),
|
|
temp )
|
|
else:
|
|
return temp
|
|
|
|
class NEI(NamedInt, Enum):
|
|
__qualname__ = 'NEI'
|
|
x = ('the-x', 1)
|
|
y = ('the-y', 2)
|
|
def __reduce_ex__(self, proto):
|
|
return getattr, (self.__class__, self._name_)
|
|
|
|
self.assertIs(NEI.__new__, Enum.__new__)
|
|
self.assertEqual(repr(NEI.x + NEI.y), "NamedInt('(the-x + the-y)', 3)")
|
|
globals()['NamedInt'] = NamedInt
|
|
globals()['NEI'] = NEI
|
|
NI5 = NamedInt('test', 5)
|
|
self.assertEqual(NI5, 5)
|
|
self.assertEqual(NEI.y.value, 2)
|
|
test_pickle_dump_load(self.assertIs, NEI.y)
|
|
test_pickle_dump_load(self.assertIs, NEI)
|
|
|
|
def test_tuple_subclass(self):
|
|
class SomeTuple(tuple, Enum):
|
|
__qualname__ = 'SomeTuple' # needed for pickle protocol 4
|
|
first = (1, 'for the money')
|
|
second = (2, 'for the show')
|
|
third = (3, 'for the music')
|
|
self.assertIs(type(SomeTuple.first), SomeTuple)
|
|
self.assertIsInstance(SomeTuple.second, tuple)
|
|
self.assertEqual(SomeTuple.third, (3, 'for the music'))
|
|
globals()['SomeTuple'] = SomeTuple
|
|
test_pickle_dump_load(self.assertIs, SomeTuple.first)
|
|
|
|
def test_duplicate_values_give_unique_enum_items(self):
|
|
class AutoNumber(Enum):
|
|
first = ()
|
|
second = ()
|
|
third = ()
|
|
def __new__(cls):
|
|
value = len(cls.__members__) + 1
|
|
obj = object.__new__(cls)
|
|
obj._value_ = value
|
|
return obj
|
|
def __int__(self):
|
|
return int(self._value_)
|
|
self.assertEqual(
|
|
list(AutoNumber),
|
|
[AutoNumber.first, AutoNumber.second, AutoNumber.third],
|
|
)
|
|
self.assertEqual(int(AutoNumber.second), 2)
|
|
self.assertEqual(AutoNumber.third.value, 3)
|
|
self.assertIs(AutoNumber(1), AutoNumber.first)
|
|
|
|
def test_inherited_new_from_enhanced_enum(self):
|
|
class AutoNumber(Enum):
|
|
def __new__(cls):
|
|
value = len(cls.__members__) + 1
|
|
obj = object.__new__(cls)
|
|
obj._value_ = value
|
|
return obj
|
|
def __int__(self):
|
|
return int(self._value_)
|
|
class Color(AutoNumber):
|
|
red = ()
|
|
green = ()
|
|
blue = ()
|
|
self.assertEqual(list(Color), [Color.red, Color.green, Color.blue])
|
|
self.assertEqual(list(map(int, Color)), [1, 2, 3])
|
|
|
|
def test_inherited_new_from_mixed_enum(self):
|
|
class AutoNumber(IntEnum):
|
|
def __new__(cls):
|
|
value = len(cls.__members__) + 1
|
|
obj = int.__new__(cls, value)
|
|
obj._value_ = value
|
|
return obj
|
|
class Color(AutoNumber):
|
|
red = ()
|
|
green = ()
|
|
blue = ()
|
|
self.assertEqual(list(Color), [Color.red, Color.green, Color.blue])
|
|
self.assertEqual(list(map(int, Color)), [1, 2, 3])
|
|
|
|
def test_equality(self):
|
|
class AlwaysEqual:
|
|
def __eq__(self, other):
|
|
return True
|
|
class OrdinaryEnum(Enum):
|
|
a = 1
|
|
self.assertEqual(AlwaysEqual(), OrdinaryEnum.a)
|
|
self.assertEqual(OrdinaryEnum.a, AlwaysEqual())
|
|
|
|
def test_ordered_mixin(self):
|
|
class OrderedEnum(Enum):
|
|
def __ge__(self, other):
|
|
if self.__class__ is other.__class__:
|
|
return self._value_ >= other._value_
|
|
return NotImplemented
|
|
def __gt__(self, other):
|
|
if self.__class__ is other.__class__:
|
|
return self._value_ > other._value_
|
|
return NotImplemented
|
|
def __le__(self, other):
|
|
if self.__class__ is other.__class__:
|
|
return self._value_ <= other._value_
|
|
return NotImplemented
|
|
def __lt__(self, other):
|
|
if self.__class__ is other.__class__:
|
|
return self._value_ < other._value_
|
|
return NotImplemented
|
|
class Grade(OrderedEnum):
|
|
A = 5
|
|
B = 4
|
|
C = 3
|
|
D = 2
|
|
F = 1
|
|
self.assertGreater(Grade.A, Grade.B)
|
|
self.assertLessEqual(Grade.F, Grade.C)
|
|
self.assertLess(Grade.D, Grade.A)
|
|
self.assertGreaterEqual(Grade.B, Grade.B)
|
|
self.assertEqual(Grade.B, Grade.B)
|
|
self.assertNotEqual(Grade.C, Grade.D)
|
|
|
|
def test_extending2(self):
|
|
class Shade(Enum):
|
|
def shade(self):
|
|
print(self.name)
|
|
class Color(Shade):
|
|
red = 1
|
|
green = 2
|
|
blue = 3
|
|
with self.assertRaises(TypeError):
|
|
class MoreColor(Color):
|
|
cyan = 4
|
|
magenta = 5
|
|
yellow = 6
|
|
|
|
def test_extending3(self):
|
|
class Shade(Enum):
|
|
def shade(self):
|
|
return self.name
|
|
class Color(Shade):
|
|
def hex(self):
|
|
return '%s hexlified!' % self.value
|
|
class MoreColor(Color):
|
|
cyan = 4
|
|
magenta = 5
|
|
yellow = 6
|
|
self.assertEqual(MoreColor.magenta.hex(), '5 hexlified!')
|
|
|
|
|
|
def test_no_duplicates(self):
|
|
class UniqueEnum(Enum):
|
|
def __init__(self, *args):
|
|
cls = self.__class__
|
|
if any(self.value == e.value for e in cls):
|
|
a = self.name
|
|
e = cls(self.value).name
|
|
raise ValueError(
|
|
"aliases not allowed in UniqueEnum: %r --> %r"
|
|
% (a, e)
|
|
)
|
|
class Color(UniqueEnum):
|
|
red = 1
|
|
green = 2
|
|
blue = 3
|
|
with self.assertRaises(ValueError):
|
|
class Color(UniqueEnum):
|
|
red = 1
|
|
green = 2
|
|
blue = 3
|
|
grene = 2
|
|
|
|
def test_init(self):
|
|
class Planet(Enum):
|
|
MERCURY = (3.303e+23, 2.4397e6)
|
|
VENUS = (4.869e+24, 6.0518e6)
|
|
EARTH = (5.976e+24, 6.37814e6)
|
|
MARS = (6.421e+23, 3.3972e6)
|
|
JUPITER = (1.9e+27, 7.1492e7)
|
|
SATURN = (5.688e+26, 6.0268e7)
|
|
URANUS = (8.686e+25, 2.5559e7)
|
|
NEPTUNE = (1.024e+26, 2.4746e7)
|
|
def __init__(self, mass, radius):
|
|
self.mass = mass # in kilograms
|
|
self.radius = radius # in meters
|
|
@property
|
|
def surface_gravity(self):
|
|
# universal gravitational constant (m3 kg-1 s-2)
|
|
G = 6.67300E-11
|
|
return G * self.mass / (self.radius * self.radius)
|
|
self.assertEqual(round(Planet.EARTH.surface_gravity, 2), 9.80)
|
|
self.assertEqual(Planet.EARTH.value, (5.976e+24, 6.37814e6))
|
|
|
|
def test_nonhash_value(self):
|
|
class AutoNumberInAList(Enum):
|
|
def __new__(cls):
|
|
value = [len(cls.__members__) + 1]
|
|
obj = object.__new__(cls)
|
|
obj._value_ = value
|
|
return obj
|
|
class ColorInAList(AutoNumberInAList):
|
|
red = ()
|
|
green = ()
|
|
blue = ()
|
|
self.assertEqual(list(ColorInAList), [ColorInAList.red, ColorInAList.green, ColorInAList.blue])
|
|
for enum, value in zip(ColorInAList, range(3)):
|
|
value += 1
|
|
self.assertEqual(enum.value, [value])
|
|
self.assertIs(ColorInAList([value]), enum)
|
|
|
|
def test_conflicting_types_resolved_in_new(self):
|
|
class LabelledIntEnum(int, Enum):
|
|
def __new__(cls, *args):
|
|
value, label = args
|
|
obj = int.__new__(cls, value)
|
|
obj.label = label
|
|
obj._value_ = value
|
|
return obj
|
|
|
|
class LabelledList(LabelledIntEnum):
|
|
unprocessed = (1, "Unprocessed")
|
|
payment_complete = (2, "Payment Complete")
|
|
|
|
self.assertEqual(list(LabelledList), [LabelledList.unprocessed, LabelledList.payment_complete])
|
|
self.assertEqual(LabelledList.unprocessed, 1)
|
|
self.assertEqual(LabelledList(1), LabelledList.unprocessed)
|
|
|
|
|
|
class TestUnique(unittest.TestCase):
|
|
|
|
def test_unique_clean(self):
|
|
@unique
|
|
class Clean(Enum):
|
|
one = 1
|
|
two = 'dos'
|
|
tres = 4.0
|
|
@unique
|
|
class Cleaner(IntEnum):
|
|
single = 1
|
|
double = 2
|
|
triple = 3
|
|
|
|
def test_unique_dirty(self):
|
|
with self.assertRaisesRegex(ValueError, 'tres.*one'):
|
|
@unique
|
|
class Dirty(Enum):
|
|
one = 1
|
|
two = 'dos'
|
|
tres = 1
|
|
with self.assertRaisesRegex(
|
|
ValueError,
|
|
'double.*single.*turkey.*triple',
|
|
):
|
|
@unique
|
|
class Dirtier(IntEnum):
|
|
single = 1
|
|
double = 1
|
|
triple = 3
|
|
turkey = 3
|
|
|
|
def test_unique_with_name(self):
|
|
@unique
|
|
class Silly(Enum):
|
|
one = 1
|
|
two = 'dos'
|
|
name = 3
|
|
@unique
|
|
class Sillier(IntEnum):
|
|
single = 1
|
|
name = 2
|
|
triple = 3
|
|
value = 4
|
|
|
|
|
|
expected_help_output_with_docs = """\
|
|
Help on class Color in module %s:
|
|
|
|
class Color(enum.Enum)
|
|
| An enumeration.
|
|
|\x20\x20
|
|
| Method resolution order:
|
|
| Color
|
|
| enum.Enum
|
|
| builtins.object
|
|
|\x20\x20
|
|
| Data and other attributes defined here:
|
|
|\x20\x20
|
|
| blue = <Color.blue: 3>
|
|
|\x20\x20
|
|
| green = <Color.green: 2>
|
|
|\x20\x20
|
|
| red = <Color.red: 1>
|
|
|\x20\x20
|
|
| ----------------------------------------------------------------------
|
|
| Data descriptors inherited from enum.Enum:
|
|
|\x20\x20
|
|
| name
|
|
| The name of the Enum member.
|
|
|\x20\x20
|
|
| value
|
|
| The value of the Enum member.
|
|
|\x20\x20
|
|
| ----------------------------------------------------------------------
|
|
| Data descriptors inherited from enum.EnumMeta:
|
|
|\x20\x20
|
|
| __members__
|
|
| Returns a mapping of member name->value.
|
|
|\x20\x20\x20\x20\x20\x20
|
|
| This mapping lists all enum members, including aliases. Note that this
|
|
| is a read-only view of the internal mapping."""
|
|
|
|
expected_help_output_without_docs = """\
|
|
Help on class Color in module %s:
|
|
|
|
class Color(enum.Enum)
|
|
| Method resolution order:
|
|
| Color
|
|
| enum.Enum
|
|
| builtins.object
|
|
|\x20\x20
|
|
| Data and other attributes defined here:
|
|
|\x20\x20
|
|
| blue = <Color.blue: 3>
|
|
|\x20\x20
|
|
| green = <Color.green: 2>
|
|
|\x20\x20
|
|
| red = <Color.red: 1>
|
|
|\x20\x20
|
|
| ----------------------------------------------------------------------
|
|
| Data descriptors inherited from enum.Enum:
|
|
|\x20\x20
|
|
| name
|
|
|\x20\x20
|
|
| value
|
|
|\x20\x20
|
|
| ----------------------------------------------------------------------
|
|
| Data descriptors inherited from enum.EnumMeta:
|
|
|\x20\x20
|
|
| __members__"""
|
|
|
|
class TestStdLib(unittest.TestCase):
|
|
|
|
maxDiff = None
|
|
|
|
class Color(Enum):
|
|
red = 1
|
|
green = 2
|
|
blue = 3
|
|
|
|
def test_pydoc(self):
|
|
# indirectly test __objclass__
|
|
if StrEnum.__doc__ is None:
|
|
expected_text = expected_help_output_without_docs % __name__
|
|
else:
|
|
expected_text = expected_help_output_with_docs % __name__
|
|
output = StringIO()
|
|
helper = pydoc.Helper(output=output)
|
|
helper(self.Color)
|
|
result = output.getvalue().strip()
|
|
self.assertEqual(result, expected_text)
|
|
|
|
def test_inspect_getmembers(self):
|
|
values = dict((
|
|
('__class__', EnumMeta),
|
|
('__doc__', 'An enumeration.'),
|
|
('__members__', self.Color.__members__),
|
|
('__module__', __name__),
|
|
('blue', self.Color.blue),
|
|
('green', self.Color.green),
|
|
('name', Enum.__dict__['name']),
|
|
('red', self.Color.red),
|
|
('value', Enum.__dict__['value']),
|
|
))
|
|
result = dict(inspect.getmembers(self.Color))
|
|
self.assertEqual(values.keys(), result.keys())
|
|
failed = False
|
|
for k in values.keys():
|
|
if result[k] != values[k]:
|
|
print()
|
|
print('\n%s\n key: %s\n result: %s\nexpected: %s\n%s\n' %
|
|
('=' * 75, k, result[k], values[k], '=' * 75), sep='')
|
|
failed = True
|
|
if failed:
|
|
self.fail("result does not equal expected, see print above")
|
|
|
|
def test_inspect_classify_class_attrs(self):
|
|
# indirectly test __objclass__
|
|
from inspect import Attribute
|
|
values = [
|
|
Attribute(name='__class__', kind='data',
|
|
defining_class=object, object=EnumMeta),
|
|
Attribute(name='__doc__', kind='data',
|
|
defining_class=self.Color, object='An enumeration.'),
|
|
Attribute(name='__members__', kind='property',
|
|
defining_class=EnumMeta, object=EnumMeta.__members__),
|
|
Attribute(name='__module__', kind='data',
|
|
defining_class=self.Color, object=__name__),
|
|
Attribute(name='blue', kind='data',
|
|
defining_class=self.Color, object=self.Color.blue),
|
|
Attribute(name='green', kind='data',
|
|
defining_class=self.Color, object=self.Color.green),
|
|
Attribute(name='red', kind='data',
|
|
defining_class=self.Color, object=self.Color.red),
|
|
Attribute(name='name', kind='data',
|
|
defining_class=Enum, object=Enum.__dict__['name']),
|
|
Attribute(name='value', kind='data',
|
|
defining_class=Enum, object=Enum.__dict__['value']),
|
|
]
|
|
values.sort(key=lambda item: item.name)
|
|
result = list(inspect.classify_class_attrs(self.Color))
|
|
result.sort(key=lambda item: item.name)
|
|
failed = False
|
|
for v, r in zip(values, result):
|
|
if r != v:
|
|
print('\n%s\n%s\n%s\n%s\n' % ('=' * 75, r, v, '=' * 75), sep='')
|
|
failed = True
|
|
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()
|