Debian Codegraph @

Lib/test/test_enum.py

raw
1 import copy
2 import enum
3 import doctest
4 import inspect
5 import os
6 import pydoc
7 import sys
8 import unittest
9 import threading
10 import typing
11 import builtins as bltns
12 from collections import OrderedDict
13 from datetime import date
14 from enum import Enum, EnumMeta, IntEnum, StrEnum, EnumType, Flag, IntFlag, unique, auto
15 from enum import STRICT, CONFORM, EJECT, KEEP, _simple_enum, _test_simple_enum
16 from enum import verify, UNIQUE, CONTINUOUS, NAMED_FLAGS, ReprEnum
17 from enum import member, nonmember, _iter_bits_lsb, EnumDict
18 from io import StringIO
19 from pickle import dumps, loads, PicklingError, HIGHEST_PROTOCOL
20 from test import support
21 from test.support import ALWAYS_EQ, REPO_ROOT
22 from test.support import threading_helper, cpython_only
23 from test.support.import_helper import ensure_lazy_imports
24 from datetime import timedelta
25
26 python_version = sys.version_info[:2]
27
28 def load_tests(loader, tests, ignore):
29 tests.addTests(doctest.DocTestSuite(enum))
30
31 lib_tests = os.path.join(REPO_ROOT, 'Doc/library/enum.rst')
32 if os.path.exists(lib_tests):
33 tests.addTests(doctest.DocFileSuite(
34 lib_tests,
35 module_relative=False,
36 optionflags=doctest.ELLIPSIS|doctest.NORMALIZE_WHITESPACE,
37 ))
38 howto_tests = os.path.join(REPO_ROOT, 'Doc/howto/enum.rst')
39 if os.path.exists(howto_tests) and sys.float_repr_style == 'short':
40 tests.addTests(doctest.DocFileSuite(
41 howto_tests,
42 module_relative=False,
43 optionflags=doctest.ELLIPSIS|doctest.NORMALIZE_WHITESPACE,
44 ))
45 return tests
46
47 def reraise_if_not_enum(*enum_types_or_exceptions):
48 from functools import wraps
49
50 def decorator(func):
51 @wraps(func)
52 def inner(*args, **kwargs):
53 excs = [
54 e
55 for e in enum_types_or_exceptions
56 if isinstance(e, Exception)
57 ]
58 if len(excs) == 1:
59 raise excs[0]
60 elif excs:
61 raise ExceptionGroup('Enum Exceptions', excs)
62 return func(*args, **kwargs)
63 return inner
64 return decorator
65
66 MODULE = __name__
67 SHORT_MODULE = MODULE.split('.')[-1]
68
69 # for pickle tests
70 try:
71 class Stooges(Enum):
72 LARRY = 1
73 CURLY = 2
74 MOE = 3
75 except Exception as exc:
76 Stooges = exc
77
78 try:
79 class IntStooges(int, Enum):
80 LARRY = 1
81 CURLY = 2
82 MOE = 3
83 except Exception as exc:
84 IntStooges = exc
85
86 try:
87 class FloatStooges(float, Enum):
88 LARRY = 1.39
89 CURLY = 2.72
90 MOE = 3.142596
91 except Exception as exc:
92 FloatStooges = exc
93
94 try:
95 class FlagStooges(Flag):
96 LARRY = 1
97 CURLY = 2
98 MOE = 4
99 BIG = 389
100 except Exception as exc:
101 FlagStooges = exc
102
103 try:
104 class FlagStoogesWithZero(Flag):
105 NOFLAG = 0
106 LARRY = 1
107 CURLY = 2
108 MOE = 4
109 BIG = 389
110 except Exception as exc:
111 FlagStoogesWithZero = exc
112
113 try:
114 class IntFlagStooges(IntFlag):
115 LARRY = 1
116 CURLY = 2
117 MOE = 4
118 BIG = 389
119 except Exception as exc:
120 IntFlagStooges = exc
121
122 try:
123 class IntFlagStoogesWithZero(IntFlag):
124 NOFLAG = 0
125 LARRY = 1
126 CURLY = 2
127 MOE = 4
128 BIG = 389
129 except Exception as exc:
130 IntFlagStoogesWithZero = exc
131
132 # for pickle test and subclass tests
133 try:
134 class Name(StrEnum):
135 BDFL = 'Guido van Rossum'
136 FLUFL = 'Barry Warsaw'
137 except Exception as exc:
138 Name = exc
139
140 try:
141 Question = Enum('Question', 'who what when where why', module=__name__)
142 except Exception as exc:
143 Question = exc
144
145 try:
146 Answer = Enum('Answer', 'him this then there because')
147 except Exception as exc:
148 Answer = exc
149
150 try:
151 Theory = Enum('Theory', 'rule law supposition', qualname='spanish_inquisition')
152 except Exception as exc:
153 Theory = exc
154
155 # for doctests
156 try:
157 class Fruit(Enum):
158 TOMATO = 1
159 BANANA = 2
160 CHERRY = 3
161 except Exception:
162 pass
163
164 def test_pickle_dump_load(assertion, source, target=None):
165 if target is None:
166 target = source
167 for protocol in range(HIGHEST_PROTOCOL + 1):
168 assertion(loads(dumps(source, protocol=protocol)), target)
169
170 def test_pickle_exception(assertion, exception, obj):
171 for protocol in range(HIGHEST_PROTOCOL + 1):
172 with assertion(exception):
173 dumps(obj, protocol=protocol)
174
175 class TestHelpers(unittest.TestCase):
176 # _is_descriptor, _is_sunder, _is_dunder
177
178 sunder_names = '_bad_', '_good_', '_what_ho_'
179 dunder_names = '__mal__', '__bien__', '__que_que__'
180 private_names = '_MyEnum__private', '_MyEnum__still_private', '_MyEnum___triple_private'
181 private_and_sunder_names = '_MyEnum__private_', '_MyEnum__also_private_'
182 random_names = 'okay', '_semi_private', '_weird__', '_MyEnum__'
183
184 def test_is_descriptor(self):
185 class foo:
186 pass
187 for attr in ('__get__','__set__','__delete__'):
188 obj = foo()
189 self.assertFalse(enum._is_descriptor(obj))
190 setattr(obj, attr, 1)
191 self.assertTrue(enum._is_descriptor(obj))
192
193 def test_sunder(self):
194 for name in self.sunder_names + self.private_and_sunder_names:
195 self.assertTrue(enum._is_sunder(name), '%r is a not sunder name?' % name)
196 for name in self.dunder_names + self.private_names + self.random_names:
197 self.assertFalse(enum._is_sunder(name), '%r is a sunder name?' % name)
198 for s in ('_a_', '_aa_'):
199 self.assertTrue(enum._is_sunder(s))
200 for s in ('a', 'a_', '_a', '__a', 'a__', '__a__', '_a__', '__a_', '_',
201 '__', '___', '____', '_____',):
202 self.assertFalse(enum._is_sunder(s))
203
204 def test_dunder(self):
205 for name in self.dunder_names:
206 self.assertTrue(enum._is_dunder(name), '%r is a not dunder name?' % name)
207 for name in self.sunder_names + self.private_names + self.private_and_sunder_names + self.random_names:
208 self.assertFalse(enum._is_dunder(name), '%r is a dunder name?' % name)
209 for s in ('__a__', '__aa__'):
210 self.assertTrue(enum._is_dunder(s))
211 for s in ('a', 'a_', '_a', '__a', 'a__', '_a_', '_a__', '__a_', '_',
212 '__', '___', '____', '_____',):
213 self.assertFalse(enum._is_dunder(s))
214
215
216 def test_is_private(self):
217 for name in self.private_names + self.private_and_sunder_names:
218 self.assertTrue(enum._is_private('MyEnum', name), '%r is a not private name?')
219 for name in self.sunder_names + self.dunder_names + self.random_names:
220 self.assertFalse(enum._is_private('MyEnum', name), '%r is a private name?')
221
222 def test_iter_bits_lsb(self):
223 self.assertEqual(list(_iter_bits_lsb(7)), [1, 2, 4])
224 self.assertRaisesRegex(ValueError, '-8 is not a positive integer', list, _iter_bits_lsb(-8))
225
226
227 # for subclassing tests
228
229 class classproperty:
230
231 def __init__(self, fget=None, fset=None, fdel=None, doc=None):
232 self.fget = fget
233 self.fset = fset
234 self.fdel = fdel
235 if doc is None and fget is not None:
236 doc = fget.__doc__
237 self.__doc__ = doc
238
239 def __get__(self, instance, ownerclass):
240 return self.fget(ownerclass)
241
242 # for global repr tests
243
244 try:
245 @enum.global_enum
246 class HeadlightsK(IntFlag, boundary=enum.KEEP):
247 OFF_K = 0
248 LOW_BEAM_K = auto()
249 HIGH_BEAM_K = auto()
250 FOG_K = auto()
251 except Exception as exc:
252 HeadlightsK = exc
253
254
255 try:
256 @enum.global_enum
257 class HeadlightsC(IntFlag, boundary=enum.CONFORM):
258 OFF_C = 0
259 LOW_BEAM_C = auto()
260 HIGH_BEAM_C = auto()
261 FOG_C = auto()
262 except Exception as exc:
263 HeadlightsC = exc
264
265
266 try:
267 @enum.global_enum
268 class NoName(Flag):
269 ONE = 1
270 TWO = 2
271 except Exception as exc:
272 NoName = exc
273
274
275 # tests
276
277 class _EnumTests:
278 """
279 Test for behavior that is the same across the different types of enumerations.
280 """
281
282 values = None
283
284 def setUp(self):
285 if self.__class__.__name__[-5:] == 'Class':
286 class BaseEnum(self.enum_type):
287 @enum.property
288 def first(self):
289 return '%s is first!' % self.name
290 class MainEnum(BaseEnum):
291 first = auto()
292 second = auto()
293 third = auto()
294 if issubclass(self.enum_type, Flag):
295 dupe = 3
296 else:
297 dupe = third
298 self.MainEnum = MainEnum
299 #
300 class NewStrEnum(self.enum_type):
301 def __str__(self):
302 return self.name.upper()
303 first = auto()
304 self.NewStrEnum = NewStrEnum
305 #
306 class NewFormatEnum(self.enum_type):
307 def __format__(self, spec):
308 return self.name.upper()
309 first = auto()
310 self.NewFormatEnum = NewFormatEnum
311 #
312 class NewStrFormatEnum(self.enum_type):
313 def __str__(self):
314 return self.name.title()
315 def __format__(self, spec):
316 return ''.join(reversed(self.name))
317 first = auto()
318 self.NewStrFormatEnum = NewStrFormatEnum
319 #
320 class NewBaseEnum(self.enum_type):
321 def __str__(self):
322 return self.name.title()
323 def __format__(self, spec):
324 return ''.join(reversed(self.name))
325 self.NewBaseEnum = NewBaseEnum
326 class NewSubEnum(NewBaseEnum):
327 first = auto()
328 self.NewSubEnum = NewSubEnum
329 #
330 class LazyGNV(self.enum_type):
331 def _generate_next_value_(name, start, last, values):
332 pass
333 self.LazyGNV = LazyGNV
334 #
335 class BusyGNV(self.enum_type):
336 @staticmethod
337 def _generate_next_value_(name, start, last, values):
338 pass
339 self.BusyGNV = BusyGNV
340 #
341 self.is_flag = False
342 self.names = ['first', 'second', 'third']
343 if issubclass(MainEnum, StrEnum):
344 self.values = self.names
345 elif MainEnum._member_type_ is str:
346 self.values = ['1', '2', '3']
347 elif issubclass(self.enum_type, Flag):
348 self.values = [1, 2, 4]
349 self.is_flag = True
350 self.dupe2 = MainEnum(5)
351 else:
352 self.values = self.values or [1, 2, 3]
353 #
354 if not getattr(self, 'source_values', False):
355 self.source_values = self.values
356 elif self.__class__.__name__[-8:] == 'Function':
357 @enum.property
358 def first(self):
359 return '%s is first!' % self.name
360 BaseEnum = self.enum_type('BaseEnum', {'first':first})
361 #
362 first = auto()
363 second = auto()
364 third = auto()
365 if issubclass(self.enum_type, Flag):
366 dupe = 3
367 else:
368 dupe = third
369 self.MainEnum = MainEnum = BaseEnum('MainEnum', dict(first=first, second=second, third=third, dupe=dupe))
370 #
371 def __str__(self):
372 return self.name.upper()
373 first = auto()
374 self.NewStrEnum = self.enum_type('NewStrEnum', (('first',first),('__str__',__str__)))
375 #
376 def __format__(self, spec):
377 return self.name.upper()
378 first = auto()
379 self.NewFormatEnum = self.enum_type('NewFormatEnum', [('first',first),('__format__',__format__)])
380 #
381 def __str__(self):
382 return self.name.title()
383 def __format__(self, spec):
384 return ''.join(reversed(self.name))
385 first = auto()
386 self.NewStrFormatEnum = self.enum_type('NewStrFormatEnum', dict(first=first, __format__=__format__, __str__=__str__))
387 #
388 def __str__(self):
389 return self.name.title()
390 def __format__(self, spec):
391 return ''.join(reversed(self.name))
392 self.NewBaseEnum = self.enum_type('NewBaseEnum', dict(__format__=__format__, __str__=__str__))
393 self.NewSubEnum = self.NewBaseEnum('NewSubEnum', 'first')
394 #
395 def _generate_next_value_(name, start, last, values):
396 pass
397 self.LazyGNV = self.enum_type('LazyGNV', {'_generate_next_value_':_generate_next_value_})
398 #
399 @staticmethod
400 def _generate_next_value_(name, start, last, values):
401 pass
402 self.BusyGNV = self.enum_type('BusyGNV', {'_generate_next_value_':_generate_next_value_})
403 #
404 self.is_flag = False
405 self.names = ['first', 'second', 'third']
406 if issubclass(MainEnum, StrEnum):
407 self.values = self.names
408 elif MainEnum._member_type_ is str:
409 self.values = ['1', '2', '3']
410 elif issubclass(self.enum_type, Flag):
411 self.values = [1, 2, 4]
412 self.is_flag = True
413 self.dupe2 = MainEnum(5)
414 else:
415 self.values = self.values or [1, 2, 3]
416 #
417 if not getattr(self, 'source_values', False):
418 self.source_values = self.values
419 else:
420 raise ValueError('unknown enum style: %r' % self.__class__.__name__)
421
422 def assertFormatIsValue(self, spec, member):
423 self.assertEqual(spec.format(member), spec.format(member.value))
424
425 def assertFormatIsStr(self, spec, member):
426 self.assertEqual(spec.format(member), spec.format(str(member)))
427
428 def test_attribute_deletion(self):
429 class Season(self.enum_type):
430 SPRING = auto()
431 SUMMER = auto()
432 AUTUMN = auto()
433 #
434 def spam(cls):
435 pass
436 #
437 self.assertHasAttr(Season, 'spam')
438 del Season.spam
439 self.assertNotHasAttr(Season, 'spam')
440 #
441 with self.assertRaises(AttributeError):
442 del Season.SPRING
443 with self.assertRaises(AttributeError):
444 del Season.DRY
445 with self.assertRaises(AttributeError):
446 del Season.SPRING.name
447
448 def test_bad_new_super(self):
449 with self.assertRaisesRegex(
450 TypeError,
451 'do not use .super...__new__;',
452 ):
453 class BadSuper(self.enum_type):
454 def __new__(cls, value):
455 obj = super().__new__(cls, value)
456 return obj
457 failed = 1
458
459 def test_basics(self):
460 TE = self.MainEnum
461 if self.is_flag:
462 self.assertEqual(repr(TE), "<flag 'MainEnum'>")
463 self.assertEqual(str(TE), "<flag 'MainEnum'>")
464 self.assertEqual(format(TE), "<flag 'MainEnum'>")
465 self.assertTrue(TE(5) is self.dupe2)
466 self.assertTrue(7 in TE)
467 else:
468 self.assertEqual(repr(TE), "<enum 'MainEnum'>")
469 self.assertEqual(str(TE), "<enum 'MainEnum'>")
470 self.assertEqual(format(TE), "<enum 'MainEnum'>")
471 self.assertEqual(list(TE), [TE.first, TE.second, TE.third])
472 self.assertEqual(
473 [m.name for m in TE],
474 self.names,
475 )
476 self.assertEqual(
477 [m.value for m in TE],
478 self.values,
479 )
480 self.assertEqual(
481 [m.first for m in TE],
482 ['first is first!', 'second is first!', 'third is first!']
483 )
484 for member, name in zip(TE, self.names, strict=True):
485 self.assertIs(TE[name], member)
486 for member, value in zip(TE, self.values, strict=True):
487 self.assertIs(TE(value), member)
488 if issubclass(TE, StrEnum):
489 self.assertTrue(TE.dupe is TE('third') is TE['dupe'])
490 elif TE._member_type_ is str:
491 self.assertTrue(TE.dupe is TE('3') is TE['dupe'])
492 elif issubclass(TE, Flag):
493 self.assertTrue(TE.dupe is TE(3) is TE['dupe'])
494 else:
495 self.assertTrue(TE.dupe is TE(self.values[2]) is TE['dupe'])
496
497 def test_bool_is_true(self):
498 class Empty(self.enum_type):
499 pass
500 self.assertTrue(Empty)
501 #
502 self.assertTrue(self.MainEnum)
503 for member in self.MainEnum:
504 self.assertTrue(member)
505
506 def test_changing_member_fails(self):
507 MainEnum = self.MainEnum
508 with self.assertRaises(AttributeError):
509 self.MainEnum.second = 'really first'
510
511 def test_contains_tf(self):
512 MainEnum = self.MainEnum
513 self.assertIn(MainEnum.first, MainEnum)
514 self.assertTrue(self.values[0] in MainEnum)
515 if type(self) not in (TestStrEnumClass, TestStrEnumFunction):
516 self.assertFalse('first' in MainEnum)
517 val = MainEnum.dupe
518 self.assertIn(val, MainEnum)
519 self.assertNotIn(float('nan'), MainEnum)
520 #
521 class OtherEnum(Enum):
522 one = auto()
523 two = auto()
524 self.assertNotIn(OtherEnum.two, MainEnum)
525 #
526 if MainEnum._member_type_ is object:
527 # enums without mixed data types will always be False
528 class NotEqualEnum(self.enum_type):
529 this = self.source_values[0]
530 that = self.source_values[1]
531 self.assertNotIn(NotEqualEnum.this, MainEnum)
532 self.assertNotIn(NotEqualEnum.that, MainEnum)
533 else:
534 # enums with mixed data types may be True
535 class EqualEnum(self.enum_type):
536 this = self.source_values[0]
537 that = self.source_values[1]
538 self.assertIn(EqualEnum.this, MainEnum)
539 self.assertIn(EqualEnum.that, MainEnum)
540
541 def test_contains_same_name_diff_enum_diff_values(self):
542 MainEnum = self.MainEnum
543 #
544 class OtherEnum(Enum):
545 first = "brand"
546 second = "new"
547 third = "values"
548 #
549 self.assertIn(MainEnum.first, MainEnum)
550 self.assertIn(MainEnum.second, MainEnum)
551 self.assertIn(MainEnum.third, MainEnum)
552 self.assertNotIn(MainEnum.first, OtherEnum)
553 self.assertNotIn(MainEnum.second, OtherEnum)
554 self.assertNotIn(MainEnum.third, OtherEnum)
555 #
556 self.assertIn(OtherEnum.first, OtherEnum)
557 self.assertIn(OtherEnum.second, OtherEnum)
558 self.assertIn(OtherEnum.third, OtherEnum)
559 self.assertNotIn(OtherEnum.first, MainEnum)
560 self.assertNotIn(OtherEnum.second, MainEnum)
561 self.assertNotIn(OtherEnum.third, MainEnum)
562
563 def test_dir_on_class(self):
564 TE = self.MainEnum
565 self.assertEqual(set(dir(TE)), set(enum_dir(TE)))
566
567 def test_dir_on_item(self):
568 TE = self.MainEnum
569 self.assertEqual(set(dir(TE.first)), set(member_dir(TE.first)))
570
571 def test_dir_with_added_behavior(self):
572 class Test(self.enum_type):
573 this = auto()
574 these = auto()
575 def wowser(self):
576 return ("Wowser! I'm %s!" % self.name)
577 self.assertTrue('wowser' not in dir(Test))
578 self.assertTrue('wowser' in dir(Test.this))
579
580 def test_dir_on_sub_with_behavior_on_super(self):
581 # see issue22506
582 class SuperEnum(self.enum_type):
583 def invisible(self):
584 return "did you see me?"
585 class SubEnum(SuperEnum):
586 sample = auto()
587 self.assertTrue('invisible' not in dir(SubEnum))
588 self.assertTrue('invisible' in dir(SubEnum.sample))
589
590 def test_dir_on_sub_with_behavior_including_instance_dict_on_super(self):
591 # see issue40084
592 class SuperEnum(self.enum_type):
593 def __new__(cls, *value, **kwds):
594 new = self.enum_type._member_type_.__new__
595 if self.enum_type._member_type_ is object:
596 obj = new(cls)
597 else:
598 if isinstance(value[0], tuple):
599 create_value ,= value[0]
600 else:
601 create_value = value
602 obj = new(cls, *create_value)
603 obj._value_ = value[0] if len(value) == 1 else value
604 obj.description = 'test description'
605 return obj
606 class SubEnum(SuperEnum):
607 sample = self.source_values[1]
608 self.assertTrue('description' not in dir(SubEnum))
609 self.assertTrue('description' in dir(SubEnum.sample), dir(SubEnum.sample))
610
611 def test_empty_enum_has_no_values(self):
612 with self.assertRaisesRegex(TypeError, "<.... 'NewBaseEnum'> has no members"):
613 self.NewBaseEnum(7)
614
615 def test_enum_in_enum_out(self):
616 Main = self.MainEnum
617 self.assertIs(Main(Main.first), Main.first)
618
619 def test_gnv_is_static(self):
620 lazy = self.LazyGNV
621 busy = self.BusyGNV
622 self.assertTrue(type(lazy.__dict__['_generate_next_value_']) is staticmethod)
623 self.assertTrue(type(busy.__dict__['_generate_next_value_']) is staticmethod)
624
625 def test_hash(self):
626 MainEnum = self.MainEnum
627 mapping = {}
628 mapping[MainEnum.first] = '1225'
629 mapping[MainEnum.second] = '0315'
630 mapping[MainEnum.third] = '0704'
631 self.assertEqual(mapping[MainEnum.second], '0315')
632
633 def test_invalid_names(self):
634 with self.assertRaises(ValueError):
635 class Wrong(self.enum_type):
636 mro = 9
637 with self.assertRaises(ValueError):
638 class Wrong(self.enum_type):
639 _create_= 11
640 with self.assertRaises(ValueError):
641 class Wrong(self.enum_type):
642 _get_mixins_ = 9
643 with self.assertRaises(ValueError):
644 class Wrong(self.enum_type):
645 _find_new_ = 1
646 with self.assertRaises(ValueError):
647 class Wrong(self.enum_type):
648 _any_name_ = 9
649
650 def test_object_str_override(self):
651 "check that setting __str__ to object's is not reset to Enum's"
652 class Generic(self.enum_type):
653 item = self.source_values[2]
654 def __repr__(self):
655 return "%s.test" % (self._name_, )
656 __str__ = object.__str__
657 self.assertEqual(str(Generic.item), 'item.test')
658
659 def test_overridden_str(self):
660 NS = self.NewStrEnum
661 self.assertEqual(str(NS.first), NS.first.name.upper())
662 self.assertEqual(format(NS.first), NS.first.name.upper())
663
664 def test_overridden_str_format(self):
665 NSF = self.NewStrFormatEnum
666 self.assertEqual(str(NSF.first), NSF.first.name.title())
667 self.assertEqual(format(NSF.first), ''.join(reversed(NSF.first.name)))
668
669 def test_overridden_str_format_inherited(self):
670 NSE = self.NewSubEnum
671 self.assertEqual(str(NSE.first), NSE.first.name.title())
672 self.assertEqual(format(NSE.first), ''.join(reversed(NSE.first.name)))
673
674 def test_programmatic_function_string(self):
675 MinorEnum = self.enum_type('MinorEnum', 'june july august')
676 lst = list(MinorEnum)
677 self.assertEqual(len(lst), len(MinorEnum))
678 self.assertEqual(len(MinorEnum), 3, MinorEnum)
679 self.assertEqual(
680 [MinorEnum.june, MinorEnum.july, MinorEnum.august],
681 lst,
682 )
683 values = self.values
684 if self.enum_type is StrEnum:
685 values = ['june','july','august']
686 for month, av in zip('june july august'.split(), values):
687 e = MinorEnum[month]
688 self.assertEqual(e.value, av, list(MinorEnum))
689 self.assertEqual(e.name, month)
690 if MinorEnum._member_type_ is not object and issubclass(MinorEnum, MinorEnum._member_type_):
691 self.assertEqual(e, av)
692 else:
693 self.assertNotEqual(e, av)
694 self.assertIn(e, MinorEnum)
695 self.assertIs(type(e), MinorEnum)
696 self.assertIs(e, MinorEnum(av))
697
698 def test_programmatic_function_string_list(self):
699 MinorEnum = self.enum_type('MinorEnum', ['june', 'july', 'august'])
700 lst = list(MinorEnum)
701 self.assertEqual(len(lst), len(MinorEnum))
702 self.assertEqual(len(MinorEnum), 3, MinorEnum)
703 self.assertEqual(
704 [MinorEnum.june, MinorEnum.july, MinorEnum.august],
705 lst,
706 )
707 values = self.values
708 if self.enum_type is StrEnum:
709 values = ['june','july','august']
710 for month, av in zip('june july august'.split(), values):
711 e = MinorEnum[month]
712 self.assertEqual(e.value, av)
713 self.assertEqual(e.name, month)
714 if MinorEnum._member_type_ is not object and issubclass(MinorEnum, MinorEnum._member_type_):
715 self.assertEqual(e, av)
716 else:
717 self.assertNotEqual(e, av)
718 self.assertIn(e, MinorEnum)
719 self.assertIs(type(e), MinorEnum)
720 self.assertIs(e, MinorEnum(av))
721
722 def test_programmatic_function_iterable(self):
723 MinorEnum = self.enum_type(
724 'MinorEnum',
725 (('june', self.source_values[0]), ('july', self.source_values[1]), ('august', self.source_values[2]))
726 )
727 lst = list(MinorEnum)
728 self.assertEqual(len(lst), len(MinorEnum))
729 self.assertEqual(len(MinorEnum), 3, MinorEnum)
730 self.assertEqual(
731 [MinorEnum.june, MinorEnum.july, MinorEnum.august],
732 lst,
733 )
734 for month, av in zip('june july august'.split(), self.values):
735 e = MinorEnum[month]
736 self.assertEqual(e.value, av)
737 self.assertEqual(e.name, month)
738 if MinorEnum._member_type_ is not object and issubclass(MinorEnum, MinorEnum._member_type_):
739 self.assertEqual(e, av)
740 else:
741 self.assertNotEqual(e, av)
742 self.assertIn(e, MinorEnum)
743 self.assertIs(type(e), MinorEnum)
744 self.assertIs(e, MinorEnum(av))
745
746 def test_programmatic_function_from_dict(self):
747 MinorEnum = self.enum_type(
748 'MinorEnum',
749 OrderedDict((('june', self.source_values[0]), ('july', self.source_values[1]), ('august', self.source_values[2])))
750 )
751 lst = list(MinorEnum)
752 self.assertEqual(len(lst), len(MinorEnum))
753 self.assertEqual(len(MinorEnum), 3, MinorEnum)
754 self.assertEqual(
755 [MinorEnum.june, MinorEnum.july, MinorEnum.august],
756 lst,
757 )
758 for month, av in zip('june july august'.split(), self.values):
759 e = MinorEnum[month]
760 if MinorEnum._member_type_ is not object and issubclass(MinorEnum, MinorEnum._member_type_):
761 self.assertEqual(e, av)
762 else:
763 self.assertNotEqual(e, av)
764 self.assertIn(e, MinorEnum)
765 self.assertIs(type(e), MinorEnum)
766 self.assertIs(e, MinorEnum(av))
767
768 def test_repr(self):
769 TE = self.MainEnum
770 if self.is_flag:
771 self.assertEqual(repr(TE(0)), "<MainEnum: 0>")
772 self.assertEqual(repr(TE.dupe), "<MainEnum.dupe: 3>")
773 self.assertEqual(repr(self.dupe2), "<MainEnum.first|third: 5>")
774 elif issubclass(TE, StrEnum):
775 self.assertEqual(repr(TE.dupe), "<MainEnum.third: 'third'>")
776 else:
777 self.assertEqual(repr(TE.dupe), "<MainEnum.third: %r>" % (self.values[2], ), TE._value_repr_)
778 for name, value, member in zip(self.names, self.values, TE, strict=True):
779 self.assertEqual(repr(member), "<MainEnum.%s: %r>" % (member.name, member.value))
780
781 def test_repr_override(self):
782 class Generic(self.enum_type):
783 first = auto()
784 second = auto()
785 third = auto()
786 def __repr__(self):
787 return "don't you just love shades of %s?" % self.name
788 self.assertEqual(
789 repr(Generic.third),
790 "don't you just love shades of third?",
791 )
792
793 def test_inherited_repr(self):
794 class MyEnum(self.enum_type):
795 def __repr__(self):
796 return "My name is %s." % self.name
797 class MySubEnum(MyEnum):
798 this = auto()
799 that = auto()
800 theother = auto()
801 self.assertEqual(repr(MySubEnum.that), "My name is that.")
802
803 def test_multiple_superclasses_repr(self):
804 class _EnumSuperClass(metaclass=EnumMeta):
805 pass
806 class E(_EnumSuperClass, Enum):
807 A = 1
808 self.assertEqual(repr(E.A), "<E.A: 1>")
809
810 def test_reversed_iteration_order(self):
811 self.assertEqual(
812 list(reversed(self.MainEnum)),
813 [self.MainEnum.third, self.MainEnum.second, self.MainEnum.first],
814 )
815
816 class _PlainOutputTests:
817
818 def test_str(self):
819 TE = self.MainEnum
820 if self.is_flag:
821 self.assertEqual(str(TE(0)), "MainEnum(0)")
822 self.assertEqual(str(TE.dupe), "MainEnum.dupe")
823 self.assertEqual(str(self.dupe2), "MainEnum.first|third")
824 else:
825 self.assertEqual(str(TE.dupe), "MainEnum.third")
826 for name, value, member in zip(self.names, self.values, TE, strict=True):
827 self.assertEqual(str(member), "MainEnum.%s" % (member.name, ))
828
829 def test_format(self):
830 TE = self.MainEnum
831 if self.is_flag:
832 self.assertEqual(format(TE.dupe), "MainEnum.dupe")
833 self.assertEqual(format(self.dupe2), "MainEnum.first|third")
834 else:
835 self.assertEqual(format(TE.dupe), "MainEnum.third")
836 for name, value, member in zip(self.names, self.values, TE, strict=True):
837 self.assertEqual(format(member), "MainEnum.%s" % (member.name, ))
838
839 def test_overridden_format(self):
840 NF = self.NewFormatEnum
841 self.assertEqual(str(NF.first), "NewFormatEnum.first", '%s %r' % (NF.__str__, NF.first))
842 self.assertEqual(format(NF.first), "FIRST")
843
844 def test_format_specs(self):
845 TE = self.MainEnum
846 self.assertFormatIsStr('{}', TE.second)
847 self.assertFormatIsStr('{:}', TE.second)
848 self.assertFormatIsStr('{:20}', TE.second)
849 self.assertFormatIsStr('{:^20}', TE.second)
850 self.assertFormatIsStr('{:>20}', TE.second)
851 self.assertFormatIsStr('{:<20}', TE.second)
852 self.assertFormatIsStr('{:5.2}', TE.second)
853
854
855 class _MixedOutputTests:
856
857 def test_str(self):
858 TE = self.MainEnum
859 if self.is_flag:
860 self.assertEqual(str(TE.dupe), "MainEnum.dupe")
861 self.assertEqual(str(self.dupe2), "MainEnum.first|third")
862 else:
863 self.assertEqual(str(TE.dupe), "MainEnum.third")
864 for name, value, member in zip(self.names, self.values, TE, strict=True):
865 self.assertEqual(str(member), "MainEnum.%s" % (member.name, ))
866
867 def test_format(self):
868 TE = self.MainEnum
869 if self.is_flag:
870 self.assertEqual(format(TE.dupe), "MainEnum.dupe")
871 self.assertEqual(format(self.dupe2), "MainEnum.first|third")
872 else:
873 self.assertEqual(format(TE.dupe), "MainEnum.third")
874 for name, value, member in zip(self.names, self.values, TE, strict=True):
875 self.assertEqual(format(member), "MainEnum.%s" % (member.name, ))
876
877 def test_overridden_format(self):
878 NF = self.NewFormatEnum
879 self.assertEqual(str(NF.first), "NewFormatEnum.first")
880 self.assertEqual(format(NF.first), "FIRST")
881
882 def test_format_specs(self):
883 TE = self.MainEnum
884 self.assertFormatIsStr('{}', TE.first)
885 self.assertFormatIsStr('{:}', TE.first)
886 self.assertFormatIsStr('{:20}', TE.first)
887 self.assertFormatIsStr('{:^20}', TE.first)
888 self.assertFormatIsStr('{:>20}', TE.first)
889 self.assertFormatIsStr('{:<20}', TE.first)
890 self.assertFormatIsStr('{:5.2}', TE.first)
891
892
893 class _MinimalOutputTests:
894
895 def test_str(self):
896 TE = self.MainEnum
897 if self.is_flag:
898 self.assertEqual(str(TE.dupe), "3")
899 self.assertEqual(str(self.dupe2), "5")
900 else:
901 self.assertEqual(str(TE.dupe), str(self.values[2]))
902 for name, value, member in zip(self.names, self.values, TE, strict=True):
903 self.assertEqual(str(member), str(value))
904
905 def test_format(self):
906 TE = self.MainEnum
907 if self.is_flag:
908 self.assertEqual(format(TE.dupe), "3")
909 self.assertEqual(format(self.dupe2), "5")
910 else:
911 self.assertEqual(format(TE.dupe), format(self.values[2]))
912 for name, value, member in zip(self.names, self.values, TE, strict=True):
913 self.assertEqual(format(member), format(value))
914
915 def test_overridden_format(self):
916 NF = self.NewFormatEnum
917 self.assertEqual(str(NF.first), str(self.values[0]))
918 self.assertEqual(format(NF.first), "FIRST")
919
920 def test_format_specs(self):
921 TE = self.MainEnum
922 self.assertFormatIsValue('{}', TE.third)
923 self.assertFormatIsValue('{:}', TE.third)
924 self.assertFormatIsValue('{:20}', TE.third)
925 self.assertFormatIsValue('{:^20}', TE.third)
926 self.assertFormatIsValue('{:>20}', TE.third)
927 self.assertFormatIsValue('{:<20}', TE.third)
928 if TE._member_type_ is float:
929 self.assertFormatIsValue('{:n}', TE.third)
930 self.assertFormatIsValue('{:5.2}', TE.third)
931 self.assertFormatIsValue('{:f}', TE.third)
932
933 def test_copy(self):
934 TE = self.MainEnum
935 copied = copy.copy(TE)
936 self.assertEqual(copied, TE)
937 self.assertIs(copied, TE)
938 deep = copy.deepcopy(TE)
939 self.assertEqual(deep, TE)
940 self.assertIs(deep, TE)
941
942 def test_copy_member(self):
943 TE = self.MainEnum
944 copied = copy.copy(TE.first)
945 self.assertIs(copied, TE.first)
946 deep = copy.deepcopy(TE.first)
947 self.assertIs(deep, TE.first)
948
949 class _FlagTests:
950
951 def test_default_missing_with_wrong_type_value(self):
952 with self.assertRaisesRegex(
953 ValueError,
954 "'RED' is not a valid ",
955 ) as ctx:
956 self.MainEnum('RED')
957 self.assertIs(ctx.exception.__context__, None)
958
959 def test_closed_invert_expectations(self):
960 class ClosedAB(self.enum_type):
961 A = 1
962 B = 2
963 MASK = 3
964 A, B = ClosedAB
965 AB_MASK = ClosedAB.MASK
966 #
967 self.assertIs(~A, B)
968 self.assertIs(~B, A)
969 self.assertIs(~(A|B), ClosedAB(0))
970 self.assertIs(~AB_MASK, ClosedAB(0))
971 self.assertIs(~ClosedAB(0), (A|B))
972 #
973 class ClosedXYZ(self.enum_type):
974 X = 4
975 Y = 2
976 Z = 1
977 MASK = 7
978 X, Y, Z = ClosedXYZ
979 XYZ_MASK = ClosedXYZ.MASK
980 #
981 self.assertIs(~X, Y|Z)
982 self.assertIs(~Y, X|Z)
983 self.assertIs(~Z, X|Y)
984 self.assertIs(~(X|Y), Z)
985 self.assertIs(~(X|Z), Y)
986 self.assertIs(~(Y|Z), X)
987 self.assertIs(~(X|Y|Z), ClosedXYZ(0))
988 self.assertIs(~XYZ_MASK, ClosedXYZ(0))
989 self.assertIs(~ClosedXYZ(0), (X|Y|Z))
990
991 def test_open_invert_expectations(self):
992 class OpenAB(self.enum_type):
993 A = 1
994 B = 2
995 MASK = 255
996 A, B = OpenAB
997 AB_MASK = OpenAB.MASK
998 #
999 if OpenAB._boundary_ in (EJECT, KEEP):
1000 self.assertIs(~A, OpenAB(254))
1001 self.assertIs(~B, OpenAB(253))
1002 self.assertIs(~(A|B), OpenAB(252))
1003 self.assertIs(~AB_MASK, OpenAB(0))
1004 self.assertIs(~OpenAB(0), AB_MASK)
1005 else:
1006 self.assertIs(~A, B)
1007 self.assertIs(~B, A)
1008 self.assertIs(~(A|B), OpenAB(0))
1009 self.assertIs(~AB_MASK, OpenAB(0))
1010 self.assertIs(~OpenAB(0), (A|B))
1011 #
1012 class OpenXYZ(self.enum_type):
1013 X = 4
1014 Y = 2
1015 Z = 1
1016 MASK = 31
1017 X, Y, Z = OpenXYZ
1018 XYZ_MASK = OpenXYZ.MASK
1019 #
1020 if OpenXYZ._boundary_ in (EJECT, KEEP):
1021 self.assertIs(~X, OpenXYZ(27))
1022 self.assertIs(~Y, OpenXYZ(29))
1023 self.assertIs(~Z, OpenXYZ(30))
1024 self.assertIs(~(X|Y), OpenXYZ(25))
1025 self.assertIs(~(X|Z), OpenXYZ(26))
1026 self.assertIs(~(Y|Z), OpenXYZ(28))
1027 self.assertIs(~(X|Y|Z), OpenXYZ(24))
1028 self.assertIs(~XYZ_MASK, OpenXYZ(0))
1029 self.assertTrue(~OpenXYZ(0), XYZ_MASK)
1030 else:
1031 self.assertIs(~X, Y|Z)
1032 self.assertIs(~Y, X|Z)
1033 self.assertIs(~Z, X|Y)
1034 self.assertIs(~(X|Y), Z)
1035 self.assertIs(~(X|Z), Y)
1036 self.assertIs(~(Y|Z), X)
1037 self.assertIs(~(X|Y|Z), OpenXYZ(0))
1038 self.assertIs(~XYZ_MASK, OpenXYZ(0))
1039 self.assertTrue(~OpenXYZ(0), (X|Y|Z))
1040
1041
1042 class TestPlainEnumClass(_EnumTests, _PlainOutputTests, unittest.TestCase):
1043 enum_type = Enum
1044
1045
1046 class TestPlainEnumFunction(_EnumTests, _PlainOutputTests, unittest.TestCase):
1047 enum_type = Enum
1048
1049
1050 class TestPlainFlagClass(_EnumTests, _PlainOutputTests, _FlagTests, unittest.TestCase):
1051 enum_type = Flag
1052
1053 def test_none_member(self):
1054 class FlagWithNoneMember(Flag):
1055 A = 1
1056 E = None
1057
1058 self.assertEqual(FlagWithNoneMember.A.value, 1)
1059 self.assertIs(FlagWithNoneMember.E.value, None)
1060 with self.assertRaisesRegex(TypeError, r"'FlagWithNoneMember.E' cannot be combined with other flags with |"):
1061 FlagWithNoneMember.A | FlagWithNoneMember.E
1062 with self.assertRaisesRegex(TypeError, r"'FlagWithNoneMember.E' cannot be combined with other flags with &"):
1063 FlagWithNoneMember.E & FlagWithNoneMember.A
1064 with self.assertRaisesRegex(TypeError, r"'FlagWithNoneMember.E' cannot be combined with other flags with \^"):
1065 FlagWithNoneMember.A ^ FlagWithNoneMember.E
1066 with self.assertRaisesRegex(TypeError, r"'FlagWithNoneMember.E' cannot be inverted"):
1067 ~FlagWithNoneMember.E
1068
1069
1070 class TestPlainFlagFunction(_EnumTests, _PlainOutputTests, _FlagTests, unittest.TestCase):
1071 enum_type = Flag
1072
1073
1074 class TestIntEnumClass(_EnumTests, _MinimalOutputTests, unittest.TestCase):
1075 enum_type = IntEnum
1076 #
1077 def test_shadowed_attr(self):
1078 class Number(IntEnum):
1079 divisor = 1
1080 numerator = 2
1081 #
1082 self.assertEqual(Number.divisor.numerator, 1)
1083 self.assertIs(Number.numerator.divisor, Number.divisor)
1084
1085
1086 class TestIntEnumFunction(_EnumTests, _MinimalOutputTests, unittest.TestCase):
1087 enum_type = IntEnum
1088 #
1089 def test_shadowed_attr(self):
1090 Number = IntEnum('Number', ('divisor', 'numerator'))
1091 #
1092 self.assertEqual(Number.divisor.numerator, 1)
1093 self.assertIs(Number.numerator.divisor, Number.divisor)
1094
1095
1096 class TestStrEnumClass(_EnumTests, _MinimalOutputTests, unittest.TestCase):
1097 enum_type = StrEnum
1098 #
1099 def test_shadowed_attr(self):
1100 class Book(StrEnum):
1101 author = 'author'
1102 title = 'title'
1103 #
1104 self.assertEqual(Book.author.title(), 'Author')
1105 self.assertEqual(Book.title.title(), 'Title')
1106 self.assertIs(Book.title.author, Book.author)
1107
1108
1109 class TestStrEnumFunction(_EnumTests, _MinimalOutputTests, unittest.TestCase):
1110 enum_type = StrEnum
1111 #
1112 def test_shadowed_attr(self):
1113 Book = StrEnum('Book', ('author', 'title'))
1114 #
1115 self.assertEqual(Book.author.title(), 'Author')
1116 self.assertEqual(Book.title.title(), 'Title')
1117 self.assertIs(Book.title.author, Book.author)
1118
1119
1120 class TestIntFlagClass(_EnumTests, _MinimalOutputTests, _FlagTests, unittest.TestCase):
1121 enum_type = IntFlag
1122
1123
1124 class TestIntFlagFunction(_EnumTests, _MinimalOutputTests, _FlagTests, unittest.TestCase):
1125 enum_type = IntFlag
1126
1127
1128 class TestMixedIntClass(_EnumTests, _MixedOutputTests, unittest.TestCase):
1129 class enum_type(int, Enum): pass
1130
1131
1132 class TestMixedIntFunction(_EnumTests, _MixedOutputTests, unittest.TestCase):
1133 enum_type = Enum('enum_type', type=int)
1134
1135
1136 class TestMixedStrClass(_EnumTests, _MixedOutputTests, unittest.TestCase):
1137 class enum_type(str, Enum): pass
1138
1139
1140 class TestMixedStrFunction(_EnumTests, _MixedOutputTests, unittest.TestCase):
1141 enum_type = Enum('enum_type', type=str)
1142
1143
1144 class TestMixedIntFlagClass(_EnumTests, _MixedOutputTests, _FlagTests, unittest.TestCase):
1145 class enum_type(int, Flag): pass
1146
1147
1148 class TestMixedIntFlagFunction(_EnumTests, _MixedOutputTests, _FlagTests, unittest.TestCase):
1149 enum_type = Flag('enum_type', type=int)
1150
1151
1152 class TestMixedDateClass(_EnumTests, _MixedOutputTests, unittest.TestCase):
1153 #
1154 values = [date(2021, 12, 25), date(2020, 3, 15), date(2019, 11, 27)]
1155 source_values = [(2021, 12, 25), (2020, 3, 15), (2019, 11, 27)]
1156 #
1157 class enum_type(date, Enum):
1158 @staticmethod
1159 def _generate_next_value_(name, start, count, last_values):
1160 values = [(2021, 12, 25), (2020, 3, 15), (2019, 11, 27)]
1161 return values[count]
1162
1163
1164 class TestMixedDateFunction(_EnumTests, _MixedOutputTests, unittest.TestCase):
1165 #
1166 values = [date(2021, 12, 25), date(2020, 3, 15), date(2019, 11, 27)]
1167 source_values = [(2021, 12, 25), (2020, 3, 15), (2019, 11, 27)]
1168 #
1169 # staticmethod decorator will be added by EnumType if not present
1170 def _generate_next_value_(name, start, count, last_values):
1171 values = [(2021, 12, 25), (2020, 3, 15), (2019, 11, 27)]
1172 return values[count]
1173 #
1174 enum_type = Enum('enum_type', {'_generate_next_value_':_generate_next_value_}, type=date)
1175
1176
1177 class TestMinimalDateClass(_EnumTests, _MinimalOutputTests, unittest.TestCase):
1178 #
1179 values = [date(2023, 12, 1), date(2016, 2, 29), date(2009, 1, 1)]
1180 source_values = [(2023, 12, 1), (2016, 2, 29), (2009, 1, 1)]
1181 #
1182 class enum_type(date, ReprEnum):
1183 # staticmethod decorator will be added by EnumType if absent
1184 def _generate_next_value_(name, start, count, last_values):
1185 values = [(2023, 12, 1), (2016, 2, 29), (2009, 1, 1)]
1186 return values[count]
1187
1188
1189 class TestMinimalDateFunction(_EnumTests, _MinimalOutputTests, unittest.TestCase):
1190 #
1191 values = [date(2023, 12, 1), date(2016, 2, 29), date(2009, 1, 1)]
1192 source_values = [(2023, 12, 1), (2016, 2, 29), (2009, 1, 1)]
1193 #
1194 @staticmethod
1195 def _generate_next_value_(name, start, count, last_values):
1196 values = [(2023, 12, 1), (2016, 2, 29), (2009, 1, 1)]
1197 return values[count]
1198 #
1199 enum_type = ReprEnum('enum_type', {'_generate_next_value_':_generate_next_value_}, type=date)
1200
1201
1202 class TestMixedFloatClass(_EnumTests, _MixedOutputTests, unittest.TestCase):
1203 #
1204 values = [1.1, 2.2, 3.3]
1205 #
1206 class enum_type(float, Enum):
1207 def _generate_next_value_(name, start, count, last_values):
1208 values = [1.1, 2.2, 3.3]
1209 return values[count]
1210
1211
1212 class TestMixedFloatFunction(_EnumTests, _MixedOutputTests, unittest.TestCase):
1213 #
1214 values = [1.1, 2.2, 3.3]
1215 #
1216 def _generate_next_value_(name, start, count, last_values):
1217 values = [1.1, 2.2, 3.3]
1218 return values[count]
1219 #
1220 enum_type = Enum('enum_type', {'_generate_next_value_':_generate_next_value_}, type=float)
1221
1222
1223 class TestMinimalFloatClass(_EnumTests, _MinimalOutputTests, unittest.TestCase):
1224 #
1225 values = [4.4, 5.5, 6.6]
1226 #
1227 class enum_type(float, ReprEnum):
1228 def _generate_next_value_(name, start, count, last_values):
1229 values = [4.4, 5.5, 6.6]
1230 return values[count]
1231
1232
1233 class TestMinimalFloatFunction(_EnumTests, _MinimalOutputTests, unittest.TestCase):
1234 #
1235 values = [4.4, 5.5, 6.6]
1236 #
1237 def _generate_next_value_(name, start, count, last_values):
1238 values = [4.4, 5.5, 6.6]
1239 return values[count]
1240 #
1241 enum_type = ReprEnum('enum_type', {'_generate_next_value_':_generate_next_value_}, type=float)
1242
1243
1244 class TestSpecial(unittest.TestCase):
1245 """
1246 various operations that are not attributable to every possible enum
1247 """
1248
1249 def setUp(self):
1250 class Season(Enum):
1251 SPRING = 1
1252 SUMMER = 2
1253 AUTUMN = 3
1254 WINTER = 4
1255 self.Season = Season
1256 #
1257 class Grades(IntEnum):
1258 A = 5
1259 B = 4
1260 C = 3
1261 D = 2
1262 F = 0
1263 self.Grades = Grades
1264 #
1265 class Directional(str, Enum):
1266 EAST = 'east'
1267 WEST = 'west'
1268 NORTH = 'north'
1269 SOUTH = 'south'
1270 self.Directional = Directional
1271 #
1272 from datetime import date
1273 class Holiday(date, Enum):
1274 NEW_YEAR = 2013, 1, 1
1275 IDES_OF_MARCH = 2013, 3, 15
1276 self.Holiday = Holiday
1277
1278 def test_bool(self):
1279 # plain Enum members are always True
1280 class Logic(Enum):
1281 true = True
1282 false = False
1283 self.assertTrue(Logic.true)
1284 self.assertTrue(Logic.false)
1285 # unless overridden
1286 class RealLogic(Enum):
1287 true = True
1288 false = False
1289 def __bool__(self):
1290 return bool(self._value_)
1291 self.assertTrue(RealLogic.true)
1292 self.assertFalse(RealLogic.false)
1293 # mixed Enums depend on mixed-in type
1294 class IntLogic(int, Enum):
1295 true = 1
1296 false = 0
1297 self.assertTrue(IntLogic.true)
1298 self.assertFalse(IntLogic.false)
1299
1300 def test_comparisons(self):
1301 Season = self.Season
1302 with self.assertRaises(TypeError):
1303 Season.SPRING < Season.WINTER
1304 with self.assertRaises(TypeError):
1305 Season.SPRING > 4
1306 #
1307 self.assertNotEqual(Season.SPRING, 1)
1308 #
1309 class Part(Enum):
1310 SPRING = 1
1311 CLIP = 2
1312 BARREL = 3
1313 #
1314 self.assertNotEqual(Season.SPRING, Part.SPRING)
1315 with self.assertRaises(TypeError):
1316 Season.SPRING < Part.CLIP
1317
1318 @unittest.skip('to-do list')
1319 def test_dir_with_custom_dunders(self):
1320 class PlainEnum(Enum):
1321 pass
1322 cls_dir = dir(PlainEnum)
1323 self.assertNotIn('__repr__', cls_dir)
1324 self.assertNotIn('__str__', cls_dir)
1325 self.assertNotIn('__format__', cls_dir)
1326 self.assertNotIn('__init__', cls_dir)
1327 #
1328 class MyEnum(Enum):
1329 def __repr__(self):
1330 return object.__repr__(self)
1331 def __str__(self):
1332 return object.__repr__(self)
1333 def __format__(self):
1334 return object.__repr__(self)
1335 def __init__(self):
1336 pass
1337 cls_dir = dir(MyEnum)
1338 self.assertIn('__repr__', cls_dir)
1339 self.assertIn('__str__', cls_dir)
1340 self.assertIn('__format__', cls_dir)
1341 self.assertIn('__init__', cls_dir)
1342
1343 def test_duplicate_name_error(self):
1344 with self.assertRaises(TypeError):
1345 class Color(Enum):
1346 red = 1
1347 green = 2
1348 blue = 3
1349 red = 4
1350 #
1351 with self.assertRaises(TypeError):
1352 class Color(Enum):
1353 red = 1
1354 green = 2
1355 blue = 3
1356 def red(self): # noqa: F811
1357 return 'red'
1358 #
1359 with self.assertRaises(TypeError):
1360 class Color(Enum):
1361 @enum.property
1362 def red(self):
1363 return 'redder'
1364 red = 1 # noqa: F811
1365 green = 2
1366 blue = 3
1367
1368 @reraise_if_not_enum(Theory)
1369 def test_enum_function_with_qualname(self):
1370 self.assertEqual(Theory.__qualname__, 'spanish_inquisition')
1371
1372 def test_enum_of_types(self):
1373 """Support using Enum to refer to types deliberately."""
1374 class MyTypes(Enum):
1375 i = int
1376 f = float
1377 s = str
1378 self.assertEqual(MyTypes.i.value, int)
1379 self.assertEqual(MyTypes.f.value, float)
1380 self.assertEqual(MyTypes.s.value, str)
1381 class Foo:
1382 pass
1383 class Bar:
1384 pass
1385 class MyTypes2(Enum):
1386 a = Foo
1387 b = Bar
1388 self.assertEqual(MyTypes2.a.value, Foo)
1389 self.assertEqual(MyTypes2.b.value, Bar)
1390 class SpamEnumNotInner:
1391 pass
1392 class SpamEnum(Enum):
1393 spam = SpamEnumNotInner
1394 self.assertEqual(SpamEnum.spam.value, SpamEnumNotInner)
1395
1396 def test_enum_of_generic_aliases(self):
1397 class E(Enum):
1398 a = typing.List[int]
1399 b = list[int]
1400 self.assertEqual(E.a.value, typing.List[int])
1401 self.assertEqual(E.b.value, list[int])
1402 self.assertEqual(repr(E.a), '<E.a: typing.List[int]>')
1403 self.assertEqual(repr(E.b), '<E.b: list[int]>')
1404
1405 @unittest.skipIf(
1406 python_version >= (3, 13),
1407 'inner classes are not members',
1408 )
1409 def test_nested_classes_in_enum_are_members(self):
1410 """
1411 Check for warnings pre-3.13
1412 """
1413 with self.assertWarnsRegex(DeprecationWarning, 'will not become a member'):
1414 class Outer(Enum):
1415 a = 1
1416 b = 2
1417 class Inner(Enum):
1418 foo = 10
1419 bar = 11
1420 self.assertTrue(isinstance(Outer.Inner, Outer))
1421 self.assertEqual(Outer.a.value, 1)
1422 self.assertEqual(Outer.Inner.value.foo.value, 10)
1423 self.assertEqual(
1424 list(Outer.Inner.value),
1425 [Outer.Inner.value.foo, Outer.Inner.value.bar],
1426 )
1427 self.assertEqual(
1428 list(Outer),
1429 [Outer.a, Outer.b, Outer.Inner],
1430 )
1431
1432 @unittest.skipIf(
1433 python_version < (3, 13),
1434 'inner classes are still members',
1435 )
1436 def test_nested_classes_in_enum_are_not_members(self):
1437 """Support locally-defined nested classes."""
1438 class Outer(Enum):
1439 a = 1
1440 b = 2
1441 class Inner(Enum):
1442 foo = 10
1443 bar = 11
1444 self.assertTrue(isinstance(Outer.Inner, type))
1445 self.assertEqual(Outer.a.value, 1)
1446 self.assertEqual(Outer.Inner.foo.value, 10)
1447 self.assertEqual(
1448 list(Outer.Inner),
1449 [Outer.Inner.foo, Outer.Inner.bar],
1450 )
1451 self.assertEqual(
1452 list(Outer),
1453 [Outer.a, Outer.b],
1454 )
1455
1456 def test_nested_classes_in_enum_with_nonmember(self):
1457 class Outer(Enum):
1458 a = 1
1459 b = 2
1460 @nonmember
1461 class Inner(Enum):
1462 foo = 10
1463 bar = 11
1464 self.assertTrue(isinstance(Outer.Inner, type))
1465 self.assertEqual(Outer.a.value, 1)
1466 self.assertEqual(Outer.Inner.foo.value, 10)
1467 self.assertEqual(
1468 list(Outer.Inner),
1469 [Outer.Inner.foo, Outer.Inner.bar],
1470 )
1471 self.assertEqual(
1472 list(Outer),
1473 [Outer.a, Outer.b],
1474 )
1475
1476 def test_enum_of_types_with_nonmember(self):
1477 """Support using Enum to refer to types deliberately."""
1478 class MyTypes(Enum):
1479 i = int
1480 f = nonmember(float)
1481 s = str
1482 self.assertEqual(MyTypes.i.value, int)
1483 self.assertTrue(MyTypes.f is float)
1484 self.assertEqual(MyTypes.s.value, str)
1485 class Foo:
1486 pass
1487 class Bar:
1488 pass
1489 class MyTypes2(Enum):
1490 a = Foo
1491 b = nonmember(Bar)
1492 self.assertEqual(MyTypes2.a.value, Foo)
1493 self.assertTrue(MyTypes2.b is Bar)
1494 class SpamEnumIsInner:
1495 pass
1496 class SpamEnum(Enum):
1497 spam = nonmember(SpamEnumIsInner)
1498 self.assertTrue(SpamEnum.spam is SpamEnumIsInner)
1499
1500 def test_using_members_as_nonmember(self):
1501 class Example(Flag):
1502 A = 1
1503 B = 2
1504 ALL = nonmember(A | B)
1505
1506 self.assertEqual(Example.A.value, 1)
1507 self.assertEqual(Example.B.value, 2)
1508 self.assertEqual(Example.ALL, 3)
1509 self.assertIs(type(Example.ALL), int)
1510
1511 class Example(Flag):
1512 A = auto()
1513 B = auto()
1514 ALL = nonmember(A | B)
1515
1516 self.assertEqual(Example.A.value, 1)
1517 self.assertEqual(Example.B.value, 2)
1518 self.assertEqual(Example.ALL, 3)
1519 self.assertIs(type(Example.ALL), int)
1520
1521 def test_nested_classes_in_enum_with_member(self):
1522 """Support locally-defined nested classes."""
1523 class Outer(Enum):
1524 a = 1
1525 b = 2
1526 @member
1527 class Inner(Enum):
1528 foo = 10
1529 bar = 11
1530 self.assertTrue(isinstance(Outer.Inner, Outer))
1531 self.assertEqual(Outer.a.value, 1)
1532 self.assertEqual(Outer.Inner.value.foo.value, 10)
1533 self.assertEqual(
1534 list(Outer.Inner.value),
1535 [Outer.Inner.value.foo, Outer.Inner.value.bar],
1536 )
1537 self.assertEqual(
1538 list(Outer),
1539 [Outer.a, Outer.b, Outer.Inner],
1540 )
1541
1542 def test_enum_with_value_name(self):
1543 class Huh(Enum):
1544 name = 1
1545 value = 2
1546 self.assertEqual(list(Huh), [Huh.name, Huh.value])
1547 self.assertIs(type(Huh.name), Huh)
1548 self.assertEqual(Huh.name.name, 'name')
1549 self.assertEqual(Huh.name.value, 1)
1550
1551 def test_contains_name_and_value_overlap(self):
1552 class IntEnum1(IntEnum):
1553 X = 1
1554 class IntEnum2(IntEnum):
1555 X = 1
1556 class IntEnum3(IntEnum):
1557 X = 2
1558 class IntEnum4(IntEnum):
1559 Y = 1
1560 self.assertIn(IntEnum1.X, IntEnum1)
1561 self.assertIn(IntEnum1.X, IntEnum2)
1562 self.assertNotIn(IntEnum1.X, IntEnum3)
1563 self.assertIn(IntEnum1.X, IntEnum4)
1564
1565 def test_contains_different_types_same_members(self):
1566 class IntEnum1(IntEnum):
1567 X = 1
1568 class IntFlag1(IntFlag):
1569 X = 1
1570 self.assertIn(IntEnum1.X, IntFlag1)
1571 self.assertIn(IntFlag1.X, IntEnum1)
1572
1573 def test_contains_does_not_call_missing(self):
1574 class AnEnum(Enum):
1575 UNKNOWN = None
1576 LUCKY = 3
1577 @classmethod
1578 def _missing_(cls, *values):
1579 return cls.UNKNOWN
1580 self.assertTrue(None in AnEnum)
1581 self.assertTrue(3 in AnEnum)
1582 self.assertFalse(7 in AnEnum)
1583
1584 def test_inherited_data_type(self):
1585 class HexInt(int):
1586 __qualname__ = 'HexInt'
1587 def __repr__(self):
1588 return hex(self)
1589 class MyEnum(HexInt, enum.Enum):
1590 __qualname__ = 'MyEnum'
1591 A = 1
1592 B = 2
1593 C = 3
1594 self.assertEqual(repr(MyEnum.A), '<MyEnum.A: 0x1>')
1595 globals()['HexInt'] = HexInt
1596 globals()['MyEnum'] = MyEnum
1597 test_pickle_dump_load(self.assertIs, MyEnum.A)
1598 test_pickle_dump_load(self.assertIs, MyEnum)
1599 #
1600 class SillyInt(HexInt):
1601 __qualname__ = 'SillyInt'
1602 class MyOtherEnum(SillyInt, enum.Enum):
1603 __qualname__ = 'MyOtherEnum'
1604 D = 4
1605 E = 5
1606 F = 6
1607 self.assertIs(MyOtherEnum._member_type_, SillyInt)
1608 globals()['SillyInt'] = SillyInt
1609 globals()['MyOtherEnum'] = MyOtherEnum
1610 test_pickle_dump_load(self.assertIs, MyOtherEnum.E)
1611 test_pickle_dump_load(self.assertIs, MyOtherEnum)
1612 #
1613 # This did not work in 3.10, but does now with pickling by name
1614 class UnBrokenInt(int):
1615 __qualname__ = 'UnBrokenInt'
1616 def __new__(cls, value):
1617 return int.__new__(cls, value)
1618 class MyUnBrokenEnum(UnBrokenInt, Enum):
1619 __qualname__ = 'MyUnBrokenEnum'
1620 G = 7
1621 H = 8
1622 I = 9
1623 self.assertIs(MyUnBrokenEnum._member_type_, UnBrokenInt)
1624 self.assertIs(MyUnBrokenEnum(7), MyUnBrokenEnum.G)
1625 globals()['UnBrokenInt'] = UnBrokenInt
1626 globals()['MyUnBrokenEnum'] = MyUnBrokenEnum
1627 test_pickle_dump_load(self.assertIs, MyUnBrokenEnum.I)
1628 test_pickle_dump_load(self.assertIs, MyUnBrokenEnum)
1629
1630 @reraise_if_not_enum(FloatStooges)
1631 def test_floatenum_fromhex(self):
1632 h = float.hex(FloatStooges.MOE.value)
1633 self.assertIs(FloatStooges.fromhex(h), FloatStooges.MOE)
1634 h = float.hex(FloatStooges.MOE.value + 0.01)
1635 with self.assertRaises(ValueError):
1636 FloatStooges.fromhex(h)
1637
1638 def test_programmatic_function_type(self):
1639 MinorEnum = Enum('MinorEnum', 'june july august', type=int)
1640 lst = list(MinorEnum)
1641 self.assertEqual(len(lst), len(MinorEnum))
1642 self.assertEqual(len(MinorEnum), 3, MinorEnum)
1643 self.assertEqual(
1644 [MinorEnum.june, MinorEnum.july, MinorEnum.august],
1645 lst,
1646 )
1647 for i, month in enumerate('june july august'.split(), 1):
1648 e = MinorEnum(i)
1649 self.assertEqual(e, i)
1650 self.assertEqual(e.name, month)
1651 self.assertIn(e, MinorEnum)
1652 self.assertIs(type(e), MinorEnum)
1653
1654 def test_programmatic_function_string_with_start(self):
1655 MinorEnum = Enum('MinorEnum', 'june july august', start=10)
1656 lst = list(MinorEnum)
1657 self.assertEqual(len(lst), len(MinorEnum))
1658 self.assertEqual(len(MinorEnum), 3, MinorEnum)
1659 self.assertEqual(
1660 [MinorEnum.june, MinorEnum.july, MinorEnum.august],
1661 lst,
1662 )
1663 for i, month in enumerate('june july august'.split(), 10):
1664 e = MinorEnum(i)
1665 self.assertEqual(int(e.value), i)
1666 self.assertNotEqual(e, i)
1667 self.assertEqual(e.name, month)
1668 self.assertIn(e, MinorEnum)
1669 self.assertIs(type(e), MinorEnum)
1670
1671 def test_programmatic_function_type_with_start(self):
1672 MinorEnum = Enum('MinorEnum', 'june july august', type=int, start=30)
1673 lst = list(MinorEnum)
1674 self.assertEqual(len(lst), len(MinorEnum))
1675 self.assertEqual(len(MinorEnum), 3, MinorEnum)
1676 self.assertEqual(
1677 [MinorEnum.june, MinorEnum.july, MinorEnum.august],
1678 lst,
1679 )
1680 for i, month in enumerate('june july august'.split(), 30):
1681 e = MinorEnum(i)
1682 self.assertEqual(e, i)
1683 self.assertEqual(e.name, month)
1684 self.assertIn(e, MinorEnum)
1685 self.assertIs(type(e), MinorEnum)
1686
1687 def test_programmatic_function_string_list_with_start(self):
1688 MinorEnum = Enum('MinorEnum', ['june', 'july', 'august'], start=20)
1689 lst = list(MinorEnum)
1690 self.assertEqual(len(lst), len(MinorEnum))
1691 self.assertEqual(len(MinorEnum), 3, MinorEnum)
1692 self.assertEqual(
1693 [MinorEnum.june, MinorEnum.july, MinorEnum.august],
1694 lst,
1695 )
1696 for i, month in enumerate('june july august'.split(), 20):
1697 e = MinorEnum(i)
1698 self.assertEqual(int(e.value), i)
1699 self.assertNotEqual(e, i)
1700 self.assertEqual(e.name, month)
1701 self.assertIn(e, MinorEnum)
1702 self.assertIs(type(e), MinorEnum)
1703
1704 def test_programmatic_function_type_from_subclass(self):
1705 MinorEnum = IntEnum('MinorEnum', 'june july august')
1706 lst = list(MinorEnum)
1707 self.assertEqual(len(lst), len(MinorEnum))
1708 self.assertEqual(len(MinorEnum), 3, MinorEnum)
1709 self.assertEqual(
1710 [MinorEnum.june, MinorEnum.july, MinorEnum.august],
1711 lst,
1712 )
1713 for i, month in enumerate('june july august'.split(), 1):
1714 e = MinorEnum(i)
1715 self.assertEqual(e, i)
1716 self.assertEqual(e.name, month)
1717 self.assertIn(e, MinorEnum)
1718 self.assertIs(type(e), MinorEnum)
1719
1720 def test_programmatic_function_type_from_subclass_with_start(self):
1721 MinorEnum = IntEnum('MinorEnum', 'june july august', start=40)
1722 lst = list(MinorEnum)
1723 self.assertEqual(len(lst), len(MinorEnum))
1724 self.assertEqual(len(MinorEnum), 3, MinorEnum)
1725 self.assertEqual(
1726 [MinorEnum.june, MinorEnum.july, MinorEnum.august],
1727 lst,
1728 )
1729 for i, month in enumerate('june july august'.split(), 40):
1730 e = MinorEnum(i)
1731 self.assertEqual(e, i)
1732 self.assertEqual(e.name, month)
1733 self.assertIn(e, MinorEnum)
1734 self.assertIs(type(e), MinorEnum)
1735
1736 def test_programmatic_function_is_value_call(self):
1737 class TwoPart(Enum):
1738 ONE = 1, 1.0
1739 TWO = 2, 2.0
1740 THREE = 3, 3.0
1741 self.assertRaisesRegex(ValueError, '1 is not a valid .*TwoPart', TwoPart, 1)
1742 self.assertIs(TwoPart((1, 1.0)), TwoPart.ONE)
1743 self.assertIs(TwoPart(1, 1.0), TwoPart.ONE)
1744 class ThreePart(Enum):
1745 ONE = 1, 1.0, 'one'
1746 TWO = 2, 2.0, 'two'
1747 THREE = 3, 3.0, 'three'
1748 self.assertIs(ThreePart((3, 3.0, 'three')), ThreePart.THREE)
1749 self.assertIs(ThreePart(3, 3.0, 'three'), ThreePart.THREE)
1750
1751 @reraise_if_not_enum(IntStooges)
1752 def test_intenum_from_bytes(self):
1753 self.assertIs(IntStooges.from_bytes(b'\x00\x03', 'big'), IntStooges.MOE)
1754 with self.assertRaises(ValueError):
1755 IntStooges.from_bytes(b'\x00\x05', 'big')
1756
1757 def test_reserved_sunder_error(self):
1758 with self.assertRaisesRegex(
1759 ValueError,
1760 '_sunder_ names, such as ._bad_., are reserved',
1761 ):
1762 class Bad(Enum):
1763 _bad_ = 1
1764
1765 def test_too_many_data_types(self):
1766 with self.assertRaisesRegex(TypeError, 'too many data types'):
1767 class Huh(str, int, Enum):
1768 One = 1
1769
1770 class MyStr(str):
1771 def hello(self):
1772 return 'hello, %s' % self
1773 class MyInt(int):
1774 def repr(self):
1775 return hex(self)
1776 with self.assertRaisesRegex(TypeError, 'too many data types'):
1777 class Huh(MyStr, MyInt, Enum):
1778 One = 1
1779
1780 @reraise_if_not_enum(Stooges)
1781 def test_pickle_enum(self):
1782 test_pickle_dump_load(self.assertIs, Stooges.CURLY)
1783 test_pickle_dump_load(self.assertIs, Stooges)
1784
1785 @reraise_if_not_enum(IntStooges)
1786 def test_pickle_int(self):
1787 test_pickle_dump_load(self.assertIs, IntStooges.CURLY)
1788 test_pickle_dump_load(self.assertIs, IntStooges)
1789
1790 @reraise_if_not_enum(FloatStooges)
1791 def test_pickle_float(self):
1792 test_pickle_dump_load(self.assertIs, FloatStooges.CURLY)
1793 test_pickle_dump_load(self.assertIs, FloatStooges)
1794
1795 @reraise_if_not_enum(Answer)
1796 def test_pickle_enum_function(self):
1797 test_pickle_dump_load(self.assertIs, Answer.him)
1798 test_pickle_dump_load(self.assertIs, Answer)
1799
1800 @reraise_if_not_enum(Question)
1801 def test_pickle_enum_function_with_module(self):
1802 test_pickle_dump_load(self.assertIs, Question.who)
1803 test_pickle_dump_load(self.assertIs, Question)
1804
1805 def test_pickle_nested_class(self):
1806 # would normally just have this directly in the class namespace
1807 class NestedEnum(Enum):
1808 twigs = 'common'
1809 shiny = 'rare'
1810
1811 self.__class__.NestedEnum = NestedEnum
1812 self.NestedEnum.__qualname__ = '%s.NestedEnum' % self.__class__.__name__
1813 test_pickle_dump_load(self.assertIs, self.NestedEnum.twigs)
1814
1815 def test_pickle_by_name(self):
1816 class ReplaceGlobalInt(IntEnum):
1817 ONE = 1
1818 TWO = 2
1819 ReplaceGlobalInt.__reduce_ex__ = enum._reduce_ex_by_global_name
1820 for proto in range(HIGHEST_PROTOCOL):
1821 self.assertEqual(ReplaceGlobalInt.TWO.__reduce_ex__(proto), 'TWO')
1822
1823 def test_pickle_explodes(self):
1824 BadPickle = Enum(
1825 'BadPickle', 'dill sweet bread-n-butter', module=__name__)
1826 globals()['BadPickle'] = BadPickle
1827 # now break BadPickle to test exception raising
1828 enum._make_class_unpicklable(BadPickle)
1829 test_pickle_exception(self.assertRaises, TypeError, BadPickle.dill)
1830 test_pickle_exception(self.assertRaises, PicklingError, BadPickle)
1831
1832 def test_string_enum(self):
1833 class SkillLevel(str, Enum):
1834 master = 'what is the sound of one hand clapping?'
1835 journeyman = 'why did the chicken cross the road?'
1836 apprentice = 'knock, knock!'
1837 self.assertEqual(SkillLevel.apprentice, 'knock, knock!')
1838
1839 def test_getattr_getitem(self):
1840 class Period(Enum):
1841 morning = 1
1842 noon = 2
1843 evening = 3
1844 night = 4
1845 self.assertIs(Period(2), Period.noon)
1846 self.assertIs(getattr(Period, 'night'), Period.night)
1847 self.assertIs(Period['morning'], Period.morning)
1848
1849 def test_getattr_dunder(self):
1850 Season = self.Season
1851 self.assertTrue(getattr(Season, '__eq__'))
1852
1853 def test_iteration_order(self):
1854 class Season(Enum):
1855 SUMMER = 2
1856 WINTER = 4
1857 AUTUMN = 3
1858 SPRING = 1
1859 self.assertEqual(
1860 list(Season),
1861 [Season.SUMMER, Season.WINTER, Season.AUTUMN, Season.SPRING],
1862 )
1863
1864 @reraise_if_not_enum(Name)
1865 def test_subclassing(self):
1866 self.assertEqual(Name.BDFL, 'Guido van Rossum')
1867 self.assertTrue(Name.BDFL, Name('Guido van Rossum'))
1868 self.assertIs(Name.BDFL, getattr(Name, 'BDFL'))
1869 test_pickle_dump_load(self.assertIs, Name.BDFL)
1870
1871 def test_extending(self):
1872 class Color(Enum):
1873 red = 1
1874 green = 2
1875 blue = 3
1876 #
1877 with self.assertRaises(TypeError):
1878 class MoreColor(Color):
1879 cyan = 4
1880 magenta = 5
1881 yellow = 6
1882 #
1883 with self.assertRaisesRegex(TypeError, "<enum .EvenMoreColor.> cannot extend <enum .Color.>"):
1884 class EvenMoreColor(Color, IntEnum):
1885 chartruese = 7
1886 #
1887 with self.assertRaisesRegex(ValueError, r"\(.Foo., \(.pink., .black.\)\) is not a valid .*Color"):
1888 Color('Foo', ('pink', 'black'))
1889
1890 def test_exclude_methods(self):
1891 class whatever(Enum):
1892 this = 'that'
1893 these = 'those'
1894 def really(self):
1895 return 'no, not %s' % self.value
1896 self.assertIsNot(type(whatever.really), whatever)
1897 self.assertEqual(whatever.this.really(), 'no, not that')
1898
1899 def test_wrong_inheritance_order(self):
1900 with self.assertRaises(TypeError):
1901 class Wrong(Enum, str):
1902 NotHere = 'error before this point'
1903
1904 def test_raise_custom_error_on_creation(self):
1905 class InvalidRgbColorError(ValueError):
1906 def __init__(self, r, g, b):
1907 self.r = r
1908 self.g = g
1909 self.b = b
1910 super().__init__(f'({r}, {g}, {b}) is not a valid RGB color')
1911
1912 with self.assertRaises(InvalidRgbColorError):
1913 class RgbColor(Enum):
1914 RED = (255, 0, 0)
1915 GREEN = (0, 255, 0)
1916 BLUE = (0, 0, 255)
1917 INVALID = (256, 0, 0)
1918
1919 def __init__(self, r, g, b):
1920 if not all(0 <= val <= 255 for val in (r, g, b)):
1921 raise InvalidRgbColorError(r, g, b)
1922
1923 def test_intenum_transitivity(self):
1924 class number(IntEnum):
1925 one = 1
1926 two = 2
1927 three = 3
1928 class numero(IntEnum):
1929 uno = 1
1930 dos = 2
1931 tres = 3
1932 self.assertEqual(number.one, numero.uno)
1933 self.assertEqual(number.two, numero.dos)
1934 self.assertEqual(number.three, numero.tres)
1935
1936 def test_wrong_enum_in_call(self):
1937 class Monochrome(Enum):
1938 black = 0
1939 white = 1
1940 class Gender(Enum):
1941 male = 0
1942 female = 1
1943 self.assertRaises(ValueError, Monochrome, Gender.male)
1944
1945 def test_wrong_enum_in_mixed_call(self):
1946 class Monochrome(IntEnum):
1947 black = 0
1948 white = 1
1949 class Gender(Enum):
1950 male = 0
1951 female = 1
1952 self.assertRaises(ValueError, Monochrome, Gender.male)
1953
1954 def test_mixed_enum_in_call_1(self):
1955 class Monochrome(IntEnum):
1956 black = 0
1957 white = 1
1958 class Gender(IntEnum):
1959 male = 0
1960 female = 1
1961 self.assertIs(Monochrome(Gender.female), Monochrome.white)
1962
1963 def test_mixed_enum_in_call_2(self):
1964 class Monochrome(Enum):
1965 black = 0
1966 white = 1
1967 class Gender(IntEnum):
1968 male = 0
1969 female = 1
1970 self.assertIs(Monochrome(Gender.male), Monochrome.black)
1971
1972 def test_flufl_enum(self):
1973 class Fluflnum(Enum):
1974 def __int__(self):
1975 return int(self.value)
1976 class MailManOptions(Fluflnum):
1977 option1 = 1
1978 option2 = 2
1979 option3 = 3
1980 self.assertEqual(int(MailManOptions.option1), 1)
1981
1982 def test_introspection(self):
1983 class Number(IntEnum):
1984 one = 100
1985 two = 200
1986 self.assertIs(Number.one._member_type_, int)
1987 self.assertIs(Number._member_type_, int)
1988 class String(str, Enum):
1989 yarn = 'soft'
1990 rope = 'rough'
1991 wire = 'hard'
1992 self.assertIs(String.yarn._member_type_, str)
1993 self.assertIs(String._member_type_, str)
1994 class Plain(Enum):
1995 vanilla = 'white'
1996 one = 1
1997 self.assertIs(Plain.vanilla._member_type_, object)
1998 self.assertIs(Plain._member_type_, object)
1999
2000 def test_no_such_enum_member(self):
2001 class Color(Enum):
2002 red = 1
2003 green = 2
2004 blue = 3
2005 with self.assertRaises(ValueError):
2006 Color(4)
2007 with self.assertRaises(KeyError):
2008 Color['chartreuse']
2009
2010 # tests that need to be evalualted for moving
2011
2012 def test_multiple_mixin_mro(self):
2013 class auto_enum(type(Enum)):
2014 def __new__(metacls, cls, bases, classdict):
2015 temp = type(classdict)()
2016 temp._cls_name = cls
2017 names = set(classdict._member_names)
2018 i = 0
2019 for k in classdict._member_names:
2020 v = classdict[k]
2021 if v is Ellipsis:
2022 v = i
2023 else:
2024 i = v
2025 i += 1
2026 temp[k] = v
2027 for k, v in classdict.items():
2028 if k not in names:
2029 temp[k] = v
2030 return super(auto_enum, metacls).__new__(
2031 metacls, cls, bases, temp)
2032
2033 class AutoNumberedEnum(Enum, metaclass=auto_enum):
2034 pass
2035
2036 class AutoIntEnum(IntEnum, metaclass=auto_enum):
2037 pass
2038
2039 class TestAutoNumber(AutoNumberedEnum):
2040 a = ...
2041 b = 3
2042 c = ...
2043
2044 class TestAutoInt(AutoIntEnum):
2045 a = ...
2046 b = 3
2047 c = ...
2048
2049 def test_subclasses_with_getnewargs(self):
2050 class NamedInt(int):
2051 __qualname__ = 'NamedInt' # needed for pickle protocol 4
2052 def __new__(cls, *args):
2053 _args = args
2054 name, *args = args
2055 if len(args) == 0:
2056 raise TypeError("name and value must be specified")
2057 self = int.__new__(cls, *args)
2058 self._intname = name
2059 self._args = _args
2060 return self
2061 def __getnewargs__(self):
2062 return self._args
2063 @bltns.property
2064 def __name__(self):
2065 return self._intname
2066 def __repr__(self):
2067 # repr() is updated to include the name and type info
2068 return "{}({!r}, {})".format(
2069 type(self).__name__,
2070 self.__name__,
2071 int.__repr__(self),
2072 )
2073 def __str__(self):
2074 # str() is unchanged, even if it relies on the repr() fallback
2075 base = int
2076 base_str = base.__str__
2077 if base_str.__objclass__ is object:
2078 return base.__repr__(self)
2079 return base_str(self)
2080 # for simplicity, we only define one operator that
2081 # propagates expressions
2082 def __add__(self, other):
2083 temp = int(self) + int( other)
2084 if isinstance(self, NamedInt) and isinstance(other, NamedInt):
2085 return NamedInt(
2086 '({0} + {1})'.format(self.__name__, other.__name__),
2087 temp,
2088 )
2089 else:
2090 return temp
2091
2092 class NEI(NamedInt, Enum):
2093 __qualname__ = 'NEI' # needed for pickle protocol 4
2094 x = ('the-x', 1)
2095 y = ('the-y', 2)
2096
2097
2098 self.assertIs(NEI.__new__, Enum.__new__)
2099 self.assertEqual(repr(NEI.x + NEI.y), "NamedInt('(the-x + the-y)', 3)")
2100 globals()['NamedInt'] = NamedInt
2101 globals()['NEI'] = NEI
2102 NI5 = NamedInt('test', 5)
2103 self.assertEqual(NI5, 5)
2104 test_pickle_dump_load(self.assertEqual, NI5, 5)
2105 self.assertEqual(NEI.y.value, 2)
2106 test_pickle_dump_load(self.assertIs, NEI.y)
2107 test_pickle_dump_load(self.assertIs, NEI)
2108
2109 def test_subclasses_with_getnewargs_ex(self):
2110 class NamedInt(int):
2111 __qualname__ = 'NamedInt' # needed for pickle protocol 4
2112 def __new__(cls, *args):
2113 _args = args
2114 name, *args = args
2115 if len(args) == 0:
2116 raise TypeError("name and value must be specified")
2117 self = int.__new__(cls, *args)
2118 self._intname = name
2119 self._args = _args
2120 return self
2121 def __getnewargs_ex__(self):
2122 return self._args, {}
2123 @bltns.property
2124 def __name__(self):
2125 return self._intname
2126 def __repr__(self):
2127 # repr() is updated to include the name and type info
2128 return "{}({!r}, {})".format(
2129 type(self).__name__,
2130 self.__name__,
2131 int.__repr__(self),
2132 )
2133 def __str__(self):
2134 # str() is unchanged, even if it relies on the repr() fallback
2135 base = int
2136 base_str = base.__str__
2137 if base_str.__objclass__ is object:
2138 return base.__repr__(self)
2139 return base_str(self)
2140 # for simplicity, we only define one operator that
2141 # propagates expressions
2142 def __add__(self, other):
2143 temp = int(self) + int( other)
2144 if isinstance(self, NamedInt) and isinstance(other, NamedInt):
2145 return NamedInt(
2146 '({0} + {1})'.format(self.__name__, other.__name__),
2147 temp,
2148 )
2149 else:
2150 return temp
2151
2152 class NEI(NamedInt, Enum):
2153 __qualname__ = 'NEI' # needed for pickle protocol 4
2154 x = ('the-x', 1)
2155 y = ('the-y', 2)
2156
2157
2158 self.assertIs(NEI.__new__, Enum.__new__)
2159 self.assertEqual(repr(NEI.x + NEI.y), "NamedInt('(the-x + the-y)', 3)")
2160 globals()['NamedInt'] = NamedInt
2161 globals()['NEI'] = NEI
2162 NI5 = NamedInt('test', 5)
2163 self.assertEqual(NI5, 5)
2164 test_pickle_dump_load(self.assertEqual, NI5, 5)
2165 self.assertEqual(NEI.y.value, 2)
2166 test_pickle_dump_load(self.assertIs, NEI.y)
2167 test_pickle_dump_load(self.assertIs, NEI)
2168
2169 def test_subclasses_with_reduce(self):
2170 class NamedInt(int):
2171 __qualname__ = 'NamedInt' # needed for pickle protocol 4
2172 def __new__(cls, *args):
2173 _args = args
2174 name, *args = args
2175 if len(args) == 0:
2176 raise TypeError("name and value must be specified")
2177 self = int.__new__(cls, *args)
2178 self._intname = name
2179 self._args = _args
2180 return self
2181 def __reduce__(self):
2182 return self.__class__, self._args
2183 @bltns.property
2184 def __name__(self):
2185 return self._intname
2186 def __repr__(self):
2187 # repr() is updated to include the name and type info
2188 return "{}({!r}, {})".format(
2189 type(self).__name__,
2190 self.__name__,
2191 int.__repr__(self),
2192 )
2193 def __str__(self):
2194 # str() is unchanged, even if it relies on the repr() fallback
2195 base = int
2196 base_str = base.__str__
2197 if base_str.__objclass__ is object:
2198 return base.__repr__(self)
2199 return base_str(self)
2200 # for simplicity, we only define one operator that
2201 # propagates expressions
2202 def __add__(self, other):
2203 temp = int(self) + int( other)
2204 if isinstance(self, NamedInt) and isinstance(other, NamedInt):
2205 return NamedInt(
2206 '({0} + {1})'.format(self.__name__, other.__name__),
2207 temp,
2208 )
2209 else:
2210 return temp
2211
2212 class NEI(NamedInt, Enum):
2213 __qualname__ = 'NEI' # needed for pickle protocol 4
2214 x = ('the-x', 1)
2215 y = ('the-y', 2)
2216
2217
2218 self.assertIs(NEI.__new__, Enum.__new__)
2219 self.assertEqual(repr(NEI.x + NEI.y), "NamedInt('(the-x + the-y)', 3)")
2220 globals()['NamedInt'] = NamedInt
2221 globals()['NEI'] = NEI
2222 NI5 = NamedInt('test', 5)
2223 self.assertEqual(NI5, 5)
2224 test_pickle_dump_load(self.assertEqual, NI5, 5)
2225 self.assertEqual(NEI.y.value, 2)
2226 test_pickle_dump_load(self.assertIs, NEI.y)
2227 test_pickle_dump_load(self.assertIs, NEI)
2228
2229 def test_subclasses_with_reduce_ex(self):
2230 class NamedInt(int):
2231 __qualname__ = 'NamedInt' # needed for pickle protocol 4
2232 def __new__(cls, *args):
2233 _args = args
2234 name, *args = args
2235 if len(args) == 0:
2236 raise TypeError("name and value must be specified")
2237 self = int.__new__(cls, *args)
2238 self._intname = name
2239 self._args = _args
2240 return self
2241 def __reduce_ex__(self, proto):
2242 return self.__class__, self._args
2243 @bltns.property
2244 def __name__(self):
2245 return self._intname
2246 def __repr__(self):
2247 # repr() is updated to include the name and type info
2248 return "{}({!r}, {})".format(
2249 type(self).__name__,
2250 self.__name__,
2251 int.__repr__(self),
2252 )
2253 def __str__(self):
2254 # str() is unchanged, even if it relies on the repr() fallback
2255 base = int
2256 base_str = base.__str__
2257 if base_str.__objclass__ is object:
2258 return base.__repr__(self)
2259 return base_str(self)
2260 # for simplicity, we only define one operator that
2261 # propagates expressions
2262 def __add__(self, other):
2263 temp = int(self) + int( other)
2264 if isinstance(self, NamedInt) and isinstance(other, NamedInt):
2265 return NamedInt(
2266 '({0} + {1})'.format(self.__name__, other.__name__),
2267 temp,
2268 )
2269 else:
2270 return temp
2271
2272 class NEI(NamedInt, Enum):
2273 __qualname__ = 'NEI' # needed for pickle protocol 4
2274 x = ('the-x', 1)
2275 y = ('the-y', 2)
2276
2277 self.assertIs(NEI.__new__, Enum.__new__)
2278 self.assertEqual(repr(NEI.x + NEI.y), "NamedInt('(the-x + the-y)', 3)")
2279 globals()['NamedInt'] = NamedInt
2280 globals()['NEI'] = NEI
2281 NI5 = NamedInt('test', 5)
2282 self.assertEqual(NI5, 5)
2283 test_pickle_dump_load(self.assertEqual, NI5, 5)
2284 self.assertEqual(NEI.y.value, 2)
2285 test_pickle_dump_load(self.assertIs, NEI.y)
2286 test_pickle_dump_load(self.assertIs, NEI)
2287
2288 def test_subclasses_without_direct_pickle_support(self):
2289 class NamedInt(int):
2290 __qualname__ = 'NamedInt'
2291 def __new__(cls, *args):
2292 _args = args
2293 name, *args = args
2294 if len(args) == 0:
2295 raise TypeError("name and value must be specified")
2296 self = int.__new__(cls, *args)
2297 self._intname = name
2298 self._args = _args
2299 return self
2300 @bltns.property
2301 def __name__(self):
2302 return self._intname
2303 def __repr__(self):
2304 # repr() is updated to include the name and type info
2305 return "{}({!r}, {})".format(
2306 type(self).__name__,
2307 self.__name__,
2308 int.__repr__(self),
2309 )
2310 def __str__(self):
2311 # str() is unchanged, even if it relies on the repr() fallback
2312 base = int
2313 base_str = base.__str__
2314 if base_str.__objclass__ is object:
2315 return base.__repr__(self)
2316 return base_str(self)
2317 # for simplicity, we only define one operator that
2318 # propagates expressions
2319 def __add__(self, other):
2320 temp = int(self) + int( other)
2321 if isinstance(self, NamedInt) and isinstance(other, NamedInt):
2322 return NamedInt(
2323 '({0} + {1})'.format(self.__name__, other.__name__),
2324 temp )
2325 else:
2326 return temp
2327
2328 class NEI(NamedInt, Enum):
2329 __qualname__ = 'NEI'
2330 x = ('the-x', 1)
2331 y = ('the-y', 2)
2332 self.assertIs(NEI.__new__, Enum.__new__)
2333 self.assertEqual(repr(NEI.x + NEI.y), "NamedInt('(the-x + the-y)', 3)")
2334 globals()['NamedInt'] = NamedInt
2335 globals()['NEI'] = NEI
2336 NI5 = NamedInt('test', 5)
2337 self.assertEqual(NI5, 5)
2338 self.assertEqual(NEI.y.value, 2)
2339 with self.assertRaisesRegex(TypeError, "name and value must be specified"):
2340 test_pickle_dump_load(self.assertIs, NEI.y)
2341 # fix pickle support and try again
2342 NEI.__reduce_ex__ = enum.pickle_by_enum_name
2343 test_pickle_dump_load(self.assertIs, NEI.y)
2344 test_pickle_dump_load(self.assertIs, NEI)
2345
2346 def test_subclasses_with_direct_pickle_support(self):
2347 class NamedInt(int):
2348 __qualname__ = 'NamedInt'
2349 def __new__(cls, *args):
2350 _args = args
2351 name, *args = args
2352 if len(args) == 0:
2353 raise TypeError("name and value must be specified")
2354 self = int.__new__(cls, *args)
2355 self._intname = name
2356 self._args = _args
2357 return self
2358 @bltns.property
2359 def __name__(self):
2360 return self._intname
2361 def __repr__(self):
2362 # repr() is updated to include the name and type info
2363 return "{}({!r}, {})".format(
2364 type(self).__name__,
2365 self.__name__,
2366 int.__repr__(self),
2367 )
2368 def __str__(self):
2369 # str() is unchanged, even if it relies on the repr() fallback
2370 base = int
2371 base_str = base.__str__
2372 if base_str.__objclass__ is object:
2373 return base.__repr__(self)
2374 return base_str(self)
2375 # for simplicity, we only define one operator that
2376 # propagates expressions
2377 def __add__(self, other):
2378 temp = int(self) + int( other)
2379 if isinstance(self, NamedInt) and isinstance(other, NamedInt):
2380 return NamedInt(
2381 '({0} + {1})'.format(self.__name__, other.__name__),
2382 temp,
2383 )
2384 else:
2385 return temp
2386
2387 class NEI(NamedInt, Enum):
2388 __qualname__ = 'NEI'
2389 x = ('the-x', 1)
2390 y = ('the-y', 2)
2391 def __reduce_ex__(self, proto):
2392 return getattr, (self.__class__, self._name_)
2393
2394 self.assertIs(NEI.__new__, Enum.__new__)
2395 self.assertEqual(repr(NEI.x + NEI.y), "NamedInt('(the-x + the-y)', 3)")
2396 globals()['NamedInt'] = NamedInt
2397 globals()['NEI'] = NEI
2398 NI5 = NamedInt('test', 5)
2399 self.assertEqual(NI5, 5)
2400 self.assertEqual(NEI.y.value, 2)
2401 test_pickle_dump_load(self.assertIs, NEI.y)
2402 test_pickle_dump_load(self.assertIs, NEI)
2403
2404 def test_tuple_subclass(self):
2405 class SomeTuple(tuple, Enum):
2406 __qualname__ = 'SomeTuple' # needed for pickle protocol 4
2407 first = (1, 'for the money')
2408 second = (2, 'for the show')
2409 third = (3, 'for the music')
2410 self.assertIs(type(SomeTuple.first), SomeTuple)
2411 self.assertIsInstance(SomeTuple.second, tuple)
2412 self.assertEqual(SomeTuple.third, (3, 'for the music'))
2413 globals()['SomeTuple'] = SomeTuple
2414 test_pickle_dump_load(self.assertIs, SomeTuple.first)
2415
2416 def test_tuple_subclass_with_auto_1(self):
2417 from collections import namedtuple
2418 T = namedtuple('T', 'index desc')
2419 class SomeEnum(T, Enum):
2420 __qualname__ = 'SomeEnum' # needed for pickle protocol 4
2421 first = auto(), 'for the money'
2422 second = auto(), 'for the show'
2423 third = auto(), 'for the music'
2424 self.assertIs(type(SomeEnum.first), SomeEnum)
2425 self.assertEqual(SomeEnum.third.value, (3, 'for the music'))
2426 self.assertIsInstance(SomeEnum.third.value, T)
2427 self.assertEqual(SomeEnum.first.index, 1)
2428 self.assertEqual(SomeEnum.second.desc, 'for the show')
2429 globals()['SomeEnum'] = SomeEnum
2430 globals()['T'] = T
2431 test_pickle_dump_load(self.assertIs, SomeEnum.first)
2432
2433 def test_tuple_subclass_with_auto_2(self):
2434 from collections import namedtuple
2435 T = namedtuple('T', 'index desc')
2436 class SomeEnum(Enum):
2437 __qualname__ = 'SomeEnum' # needed for pickle protocol 4
2438 first = T(auto(), 'for the money')
2439 second = T(auto(), 'for the show')
2440 third = T(auto(), 'for the music')
2441 self.assertIs(type(SomeEnum.first), SomeEnum)
2442 self.assertEqual(SomeEnum.third.value, (3, 'for the music'))
2443 self.assertIsInstance(SomeEnum.third.value, T)
2444 self.assertEqual(SomeEnum.first.value.index, 1)
2445 self.assertEqual(SomeEnum.second.value.desc, 'for the show')
2446 globals()['SomeEnum'] = SomeEnum
2447 globals()['T'] = T
2448 test_pickle_dump_load(self.assertIs, SomeEnum.first)
2449
2450 def test_duplicate_values_give_unique_enum_items(self):
2451 class AutoNumber(Enum):
2452 first = ()
2453 second = ()
2454 third = ()
2455 def __new__(cls):
2456 value = len(cls.__members__) + 1
2457 obj = object.__new__(cls)
2458 obj._value_ = value
2459 return obj
2460 def __int__(self):
2461 return int(self._value_)
2462 self.assertEqual(
2463 list(AutoNumber),
2464 [AutoNumber.first, AutoNumber.second, AutoNumber.third],
2465 )
2466 self.assertEqual(int(AutoNumber.second), 2)
2467 self.assertEqual(AutoNumber.third.value, 3)
2468 self.assertIs(AutoNumber(1), AutoNumber.first)
2469
2470 def test_inherited_new_from_enhanced_enum(self):
2471 class AutoNumber(Enum):
2472 def __new__(cls):
2473 value = len(cls.__members__) + 1
2474 obj = object.__new__(cls)
2475 obj._value_ = value
2476 return obj
2477 def __int__(self):
2478 return int(self._value_)
2479 class Color(AutoNumber):
2480 red = ()
2481 green = ()
2482 blue = ()
2483 self.assertEqual(list(Color), [Color.red, Color.green, Color.blue])
2484 self.assertEqual(list(map(int, Color)), [1, 2, 3])
2485
2486 def test_inherited_new_from_mixed_enum(self):
2487 class AutoNumber(IntEnum):
2488 def __new__(cls):
2489 value = len(cls.__members__) + 1
2490 obj = int.__new__(cls, value)
2491 obj._value_ = value
2492 return obj
2493 class Color(AutoNumber):
2494 red = ()
2495 green = ()
2496 blue = ()
2497 self.assertEqual(list(Color), [Color.red, Color.green, Color.blue])
2498 self.assertEqual(list(map(int, Color)), [1, 2, 3])
2499
2500 def test_equality(self):
2501 class OrdinaryEnum(Enum):
2502 a = 1
2503 self.assertEqual(ALWAYS_EQ, OrdinaryEnum.a)
2504 self.assertEqual(OrdinaryEnum.a, ALWAYS_EQ)
2505
2506 def test_ordered_mixin(self):
2507 class OrderedEnum(Enum):
2508 def __ge__(self, other):
2509 if self.__class__ is other.__class__:
2510 return self._value_ >= other._value_
2511 return NotImplemented
2512 def __gt__(self, other):
2513 if self.__class__ is other.__class__:
2514 return self._value_ > other._value_
2515 return NotImplemented
2516 def __le__(self, other):
2517 if self.__class__ is other.__class__:
2518 return self._value_ <= other._value_
2519 return NotImplemented
2520 def __lt__(self, other):
2521 if self.__class__ is other.__class__:
2522 return self._value_ < other._value_
2523 return NotImplemented
2524 class Grade(OrderedEnum):
2525 A = 5
2526 B = 4
2527 C = 3
2528 D = 2
2529 F = 1
2530 self.assertGreater(Grade.A, Grade.B)
2531 self.assertLessEqual(Grade.F, Grade.C)
2532 self.assertLess(Grade.D, Grade.A)
2533 self.assertGreaterEqual(Grade.B, Grade.B)
2534 self.assertEqual(Grade.B, Grade.B)
2535 self.assertNotEqual(Grade.C, Grade.D)
2536
2537 def test_extending2(self):
2538 class Shade(Enum):
2539 def shade(self):
2540 print(self.name)
2541 class Color(Shade):
2542 red = 1
2543 green = 2
2544 blue = 3
2545 with self.assertRaises(TypeError):
2546 class MoreColor(Color):
2547 cyan = 4
2548 magenta = 5
2549 yellow = 6
2550
2551 def test_extending3(self):
2552 class Shade(Enum):
2553 def shade(self):
2554 return self.name
2555 class Color(Shade):
2556 def hex(self):
2557 return '%s hexlified!' % self.value
2558 class MoreColor(Color):
2559 cyan = 4
2560 magenta = 5
2561 yellow = 6
2562 self.assertEqual(MoreColor.magenta.hex(), '5 hexlified!')
2563
2564 def test_subclass_duplicate_name(self):
2565 class Base(Enum):
2566 def test(self):
2567 pass
2568 class Test(Base):
2569 test = 1
2570 self.assertIs(type(Test.test), Test)
2571
2572 def test_subclass_duplicate_name_dynamic(self):
2573 from types import DynamicClassAttribute
2574 class Base(Enum):
2575 @DynamicClassAttribute
2576 def test(self):
2577 return 'dynamic'
2578 class Test(Base):
2579 test = 1
2580 self.assertEqual(Test.test.test, 'dynamic')
2581 self.assertEqual(Test.test.value, 1)
2582 class Base2(Enum):
2583 @enum.property
2584 def flash(self):
2585 return 'flashy dynamic'
2586 class Test(Base2):
2587 flash = 1
2588 self.assertEqual(Test.flash.flash, 'flashy dynamic')
2589 self.assertEqual(Test.flash.value, 1)
2590
2591 def test_no_duplicates(self):
2592 class UniqueEnum(Enum):
2593 def __init__(self, *args):
2594 cls = self.__class__
2595 if any(self.value == e.value for e in cls):
2596 a = self.name
2597 e = cls(self.value).name
2598 raise ValueError(
2599 "aliases not allowed in UniqueEnum: %r --> %r"
2600 % (a, e)
2601 )
2602 class Color(UniqueEnum):
2603 red = 1
2604 green = 2
2605 blue = 3
2606 with self.assertRaises(ValueError):
2607 class Color(UniqueEnum):
2608 red = 1
2609 green = 2
2610 blue = 3
2611 grene = 2
2612
2613 def test_init(self):
2614 class Planet(Enum):
2615 MERCURY = (3.303e+23, 2.4397e6)
2616 VENUS = (4.869e+24, 6.0518e6)
2617 EARTH = (5.976e+24, 6.37814e6)
2618 MARS = (6.421e+23, 3.3972e6)
2619 JUPITER = (1.9e+27, 7.1492e7)
2620 SATURN = (5.688e+26, 6.0268e7)
2621 URANUS = (8.686e+25, 2.5559e7)
2622 NEPTUNE = (1.024e+26, 2.4746e7)
2623 def __init__(self, mass, radius):
2624 self.mass = mass # in kilograms
2625 self.radius = radius # in meters
2626 @enum.property
2627 def surface_gravity(self):
2628 # universal gravitational constant (m3 kg-1 s-2)
2629 G = 6.67300E-11
2630 return G * self.mass / (self.radius * self.radius)
2631 self.assertEqual(round(Planet.EARTH.surface_gravity, 2), 9.80)
2632 self.assertEqual(Planet.EARTH.value, (5.976e+24, 6.37814e6))
2633
2634 def test_ignore(self):
2635 class Period(timedelta, Enum):
2636 '''
2637 different lengths of time
2638 '''
2639 def __new__(cls, value, period):
2640 obj = timedelta.__new__(cls, value)
2641 obj._value_ = value
2642 obj.period = period
2643 return obj
2644 _ignore_ = 'Period i'
2645 Period = vars()
2646 for i in range(13):
2647 Period['month_%d' % i] = i*30, 'month'
2648 for i in range(53):
2649 Period['week_%d' % i] = i*7, 'week'
2650 for i in range(32):
2651 Period['day_%d' % i] = i, 'day'
2652 OneDay = day_1
2653 OneWeek = week_1
2654 OneMonth = month_1
2655 self.assertNotHasAttr(Period, '_ignore_')
2656 self.assertNotHasAttr(Period, 'Period')
2657 self.assertNotHasAttr(Period, 'i')
2658 self.assertIsInstance(Period.day_1, timedelta)
2659 self.assertIs(Period.month_1, Period.day_30)
2660 self.assertIs(Period.week_4, Period.day_28)
2661
2662 def test_nonhash_value(self):
2663 class AutoNumberInAList(Enum):
2664 def __new__(cls):
2665 value = [len(cls.__members__) + 1]
2666 obj = object.__new__(cls)
2667 obj._value_ = value
2668 return obj
2669 class ColorInAList(AutoNumberInAList):
2670 red = ()
2671 green = ()
2672 blue = ()
2673 self.assertEqual(list(ColorInAList), [ColorInAList.red, ColorInAList.green, ColorInAList.blue])
2674 for enum, value in zip(ColorInAList, range(3)):
2675 value += 1
2676 self.assertEqual(enum.value, [value])
2677 self.assertIs(ColorInAList([value]), enum)
2678
2679 def test_conflicting_types_resolved_in_new(self):
2680 class LabelledIntEnum(int, Enum):
2681 def __new__(cls, *args):
2682 value, label = args
2683 obj = int.__new__(cls, value)
2684 obj.label = label
2685 obj._value_ = value
2686 return obj
2687
2688 class LabelledList(LabelledIntEnum):
2689 unprocessed = (1, "Unprocessed")
2690 payment_complete = (2, "Payment Complete")
2691
2692 self.assertEqual(list(LabelledList), [LabelledList.unprocessed, LabelledList.payment_complete])
2693 self.assertEqual(LabelledList.unprocessed, 1)
2694 self.assertEqual(LabelledList(1), LabelledList.unprocessed)
2695
2696 def test_default_missing_no_chained_exception(self):
2697 class Color(Enum):
2698 RED = 1
2699 GREEN = 2
2700 BLUE = 3
2701 try:
2702 Color(7)
2703 except ValueError as exc:
2704 self.assertTrue(exc.__context__ is None)
2705 else:
2706 raise Exception('Exception not raised.')
2707
2708 def test_missing_override(self):
2709 class Color(Enum):
2710 red = 1
2711 green = 2
2712 blue = 3
2713 @classmethod
2714 def _missing_(cls, item):
2715 if item == 'three':
2716 return cls.blue
2717 elif item == 'bad return':
2718 # trigger internal error
2719 return 5
2720 elif item == 'error out':
2721 raise ZeroDivisionError
2722 else:
2723 # trigger not found
2724 return None
2725 self.assertIs(Color('three'), Color.blue)
2726 try:
2727 Color(7)
2728 except ValueError as exc:
2729 self.assertTrue(exc.__context__ is None)
2730 else:
2731 raise Exception('Exception not raised.')
2732 try:
2733 Color('bad return')
2734 except TypeError as exc:
2735 self.assertTrue(isinstance(exc.__context__, ValueError))
2736 else:
2737 raise Exception('Exception not raised.')
2738 try:
2739 Color('error out')
2740 except ZeroDivisionError as exc:
2741 self.assertTrue(isinstance(exc.__context__, ValueError))
2742 else:
2743 raise Exception('Exception not raised.')
2744
2745 def test_missing_exceptions_reset(self):
2746 import gc
2747 import weakref
2748 #
2749 class TestEnum(enum.Enum):
2750 VAL1 = 'val1'
2751 VAL2 = 'val2'
2752 #
2753 class Class1:
2754 def __init__(self):
2755 # Gracefully handle an exception of our own making
2756 try:
2757 raise ValueError()
2758 except ValueError:
2759 pass
2760 #
2761 class Class2:
2762 def __init__(self):
2763 # Gracefully handle an exception of Enum's making
2764 try:
2765 TestEnum('invalid_value')
2766 except ValueError:
2767 pass
2768 # No strong refs here so these are free to die.
2769 class_1_ref = weakref.ref(Class1())
2770 class_2_ref = weakref.ref(Class2())
2771 #
2772 # The exception raised by Enum used to create a reference loop and thus
2773 # Class2 instances would stick around until the next garbage collection
2774 # cycle, unlike Class1. Verify Class2 no longer does this.
2775 gc.collect() # For PyPy or other GCs.
2776 self.assertIs(class_1_ref(), None)
2777 self.assertIs(class_2_ref(), None)
2778
2779 def test_multiple_mixin(self):
2780 class MaxMixin:
2781 @classproperty
2782 def MAX(cls):
2783 max = len(cls)
2784 cls.MAX = max
2785 return max
2786 class StrMixin:
2787 def __str__(self):
2788 return self._name_.lower()
2789 class SomeEnum(Enum):
2790 def behavior(self):
2791 return 'booyah'
2792 class AnotherEnum(Enum):
2793 def behavior(self):
2794 return 'nuhuh!'
2795 def social(self):
2796 return "what's up?"
2797 class Color(MaxMixin, Enum):
2798 RED = auto()
2799 GREEN = auto()
2800 BLUE = auto()
2801 self.assertEqual(Color.RED.value, 1)
2802 self.assertEqual(Color.GREEN.value, 2)
2803 self.assertEqual(Color.BLUE.value, 3)
2804 self.assertEqual(Color.MAX, 3)
2805 self.assertEqual(str(Color.BLUE), 'Color.BLUE')
2806 class Color(MaxMixin, StrMixin, Enum):
2807 RED = auto()
2808 GREEN = auto()
2809 BLUE = auto()
2810 __str__ = StrMixin.__str__ # needed as of 3.11
2811 self.assertEqual(Color.RED.value, 1)
2812 self.assertEqual(Color.GREEN.value, 2)
2813 self.assertEqual(Color.BLUE.value, 3)
2814 self.assertEqual(Color.MAX, 3)
2815 self.assertEqual(str(Color.BLUE), 'blue')
2816 class Color(StrMixin, MaxMixin, Enum):
2817 RED = auto()
2818 GREEN = auto()
2819 BLUE = auto()
2820 __str__ = StrMixin.__str__ # needed as of 3.11
2821 self.assertEqual(Color.RED.value, 1)
2822 self.assertEqual(Color.GREEN.value, 2)
2823 self.assertEqual(Color.BLUE.value, 3)
2824 self.assertEqual(Color.MAX, 3)
2825 self.assertEqual(str(Color.BLUE), 'blue')
2826 class CoolColor(StrMixin, SomeEnum, Enum):
2827 RED = auto()
2828 GREEN = auto()
2829 BLUE = auto()
2830 __str__ = StrMixin.__str__ # needed as of 3.11
2831 self.assertEqual(CoolColor.RED.value, 1)
2832 self.assertEqual(CoolColor.GREEN.value, 2)
2833 self.assertEqual(CoolColor.BLUE.value, 3)
2834 self.assertEqual(str(CoolColor.BLUE), 'blue')
2835 self.assertEqual(CoolColor.RED.behavior(), 'booyah')
2836 class CoolerColor(StrMixin, AnotherEnum, Enum):
2837 RED = auto()
2838 GREEN = auto()
2839 BLUE = auto()
2840 __str__ = StrMixin.__str__ # needed as of 3.11
2841 self.assertEqual(CoolerColor.RED.value, 1)
2842 self.assertEqual(CoolerColor.GREEN.value, 2)
2843 self.assertEqual(CoolerColor.BLUE.value, 3)
2844 self.assertEqual(str(CoolerColor.BLUE), 'blue')
2845 self.assertEqual(CoolerColor.RED.behavior(), 'nuhuh!')
2846 self.assertEqual(CoolerColor.RED.social(), "what's up?")
2847 class CoolestColor(StrMixin, SomeEnum, AnotherEnum):
2848 RED = auto()
2849 GREEN = auto()
2850 BLUE = auto()
2851 __str__ = StrMixin.__str__ # needed as of 3.11
2852 self.assertEqual(CoolestColor.RED.value, 1)
2853 self.assertEqual(CoolestColor.GREEN.value, 2)
2854 self.assertEqual(CoolestColor.BLUE.value, 3)
2855 self.assertEqual(str(CoolestColor.BLUE), 'blue')
2856 self.assertEqual(CoolestColor.RED.behavior(), 'booyah')
2857 self.assertEqual(CoolestColor.RED.social(), "what's up?")
2858 class ConfusedColor(StrMixin, AnotherEnum, SomeEnum):
2859 RED = auto()
2860 GREEN = auto()
2861 BLUE = auto()
2862 __str__ = StrMixin.__str__ # needed as of 3.11
2863 self.assertEqual(ConfusedColor.RED.value, 1)
2864 self.assertEqual(ConfusedColor.GREEN.value, 2)
2865 self.assertEqual(ConfusedColor.BLUE.value, 3)
2866 self.assertEqual(str(ConfusedColor.BLUE), 'blue')
2867 self.assertEqual(ConfusedColor.RED.behavior(), 'nuhuh!')
2868 self.assertEqual(ConfusedColor.RED.social(), "what's up?")
2869 class ReformedColor(StrMixin, IntEnum, SomeEnum, AnotherEnum):
2870 RED = auto()
2871 GREEN = auto()
2872 BLUE = auto()
2873 __str__ = StrMixin.__str__ # needed as of 3.11
2874 self.assertEqual(ReformedColor.RED.value, 1)
2875 self.assertEqual(ReformedColor.GREEN.value, 2)
2876 self.assertEqual(ReformedColor.BLUE.value, 3)
2877 self.assertEqual(str(ReformedColor.BLUE), 'blue')
2878 self.assertEqual(ReformedColor.RED.behavior(), 'booyah')
2879 self.assertEqual(ConfusedColor.RED.social(), "what's up?")
2880 self.assertIsSubclass(ReformedColor, int)
2881
2882 def test_multiple_inherited_mixin(self):
2883 @unique
2884 class Decision1(StrEnum):
2885 REVERT = "REVERT"
2886 REVERT_ALL = "REVERT_ALL"
2887 RETRY = "RETRY"
2888 class MyEnum(StrEnum):
2889 pass
2890 @unique
2891 class Decision2(MyEnum):
2892 REVERT = "REVERT"
2893 REVERT_ALL = "REVERT_ALL"
2894 RETRY = "RETRY"
2895
2896 def test_multiple_mixin_inherited(self):
2897 class MyInt(int):
2898 def __new__(cls, value):
2899 return super().__new__(cls, value)
2900
2901 class HexMixin:
2902 def __repr__(self):
2903 return hex(self)
2904
2905 class MyIntEnum(HexMixin, MyInt, enum.Enum):
2906 __repr__ = HexMixin.__repr__
2907
2908 class Foo(MyIntEnum):
2909 TEST = 1
2910 self.assertTrue(isinstance(Foo.TEST, MyInt))
2911 self.assertEqual(Foo._member_type_, MyInt)
2912 self.assertEqual(repr(Foo.TEST), "0x1")
2913
2914 class Fee(MyIntEnum):
2915 TEST = 1
2916 def __new__(cls, value):
2917 value += 1
2918 member = int.__new__(cls, value)
2919 member._value_ = value
2920 return member
2921 self.assertEqual(Fee.TEST, 2)
2922
2923 def test_multiple_mixin_with_common_data_type(self):
2924 class CaseInsensitiveStrEnum(str, Enum):
2925 @classmethod
2926 def _missing_(cls, value):
2927 for member in cls._member_map_.values():
2928 if member._value_.lower() == value.lower():
2929 return member
2930 return super()._missing_(value)
2931 #
2932 class LenientStrEnum(str, Enum):
2933 def __init__(self, *args):
2934 self._valid = True
2935 @classmethod
2936 def _missing_(cls, value):
2937 unknown = cls._member_type_.__new__(cls, value)
2938 unknown._valid = False
2939 unknown._name_ = value.upper()
2940 unknown._value_ = value
2941 cls._member_map_[value] = unknown
2942 return unknown
2943 @enum.property
2944 def valid(self):
2945 return self._valid
2946 #
2947 class JobStatus(CaseInsensitiveStrEnum, LenientStrEnum):
2948 ACTIVE = "active"
2949 PENDING = "pending"
2950 TERMINATED = "terminated"
2951 #
2952 JS = JobStatus
2953 self.assertEqual(list(JobStatus), [JS.ACTIVE, JS.PENDING, JS.TERMINATED])
2954 self.assertEqual(JS.ACTIVE, 'active')
2955 self.assertEqual(JS.ACTIVE.value, 'active')
2956 self.assertIs(JS('Active'), JS.ACTIVE)
2957 self.assertTrue(JS.ACTIVE.valid)
2958 missing = JS('missing')
2959 self.assertEqual(list(JobStatus), [JS.ACTIVE, JS.PENDING, JS.TERMINATED])
2960 self.assertEqual(JS.ACTIVE, 'active')
2961 self.assertEqual(JS.ACTIVE.value, 'active')
2962 self.assertIs(JS('Active'), JS.ACTIVE)
2963 self.assertTrue(JS.ACTIVE.valid)
2964 self.assertTrue(isinstance(missing, JS))
2965 self.assertFalse(missing.valid)
2966
2967 def test_empty_globals(self):
2968 # bpo-35717: sys._getframe(2).f_globals['__name__'] fails with KeyError
2969 # when using compile and exec because f_globals is empty
2970 code = "from enum import Enum; Enum('Animal', 'ANT BEE CAT DOG')"
2971 code = compile(code, "<string>", "exec")
2972 global_ns = {}
2973 local_ls = {}
2974 exec(code, global_ns, local_ls)
2975
2976 def test_strenum(self):
2977 class GoodStrEnum(StrEnum):
2978 one = '1'
2979 two = '2'
2980 three = b'3', 'ascii'
2981 four = b'4', 'latin1', 'strict'
2982 self.assertEqual(GoodStrEnum.one, '1')
2983 self.assertEqual(str(GoodStrEnum.one), '1')
2984 self.assertEqual('{}'.format(GoodStrEnum.one), '1')
2985 self.assertEqual(GoodStrEnum.one, str(GoodStrEnum.one))
2986 self.assertEqual(GoodStrEnum.one, '{}'.format(GoodStrEnum.one))
2987 self.assertEqual(repr(GoodStrEnum.one), "<GoodStrEnum.one: '1'>")
2988 #
2989 class DumbMixin:
2990 def __str__(self):
2991 return "don't do this"
2992 class DumbStrEnum(DumbMixin, StrEnum):
2993 five = '5'
2994 six = '6'
2995 seven = '7'
2996 __str__ = DumbMixin.__str__ # needed as of 3.11
2997 self.assertEqual(DumbStrEnum.seven, '7')
2998 self.assertEqual(str(DumbStrEnum.seven), "don't do this")
2999 #
3000 class EnumMixin(Enum):
3001 def hello(self):
3002 print('hello from %s' % (self, ))
3003 class HelloEnum(EnumMixin, StrEnum):
3004 eight = '8'
3005 self.assertEqual(HelloEnum.eight, '8')
3006 self.assertEqual(HelloEnum.eight, str(HelloEnum.eight))
3007 #
3008 class GoodbyeMixin:
3009 def goodbye(self):
3010 print('%s wishes you a fond farewell')
3011 class GoodbyeEnum(GoodbyeMixin, EnumMixin, StrEnum):
3012 nine = '9'
3013 self.assertEqual(GoodbyeEnum.nine, '9')
3014 self.assertEqual(GoodbyeEnum.nine, str(GoodbyeEnum.nine))
3015 #
3016 with self.assertRaisesRegex(TypeError, '1 is not a string'):
3017 class FirstFailedStrEnum(StrEnum):
3018 one = 1
3019 two = '2'
3020 with self.assertRaisesRegex(TypeError, "2 is not a string"):
3021 class SecondFailedStrEnum(StrEnum):
3022 one = '1'
3023 two = 2,
3024 three = '3'
3025 with self.assertRaisesRegex(TypeError, '2 is not a string'):
3026 class ThirdFailedStrEnum(StrEnum):
3027 one = '1'
3028 two = 2
3029 with self.assertRaisesRegex(TypeError, 'encoding must be a string, not %r' % (sys.getdefaultencoding, )):
3030 class ThirdFailedStrEnum(StrEnum):
3031 one = '1'
3032 two = b'2', sys.getdefaultencoding
3033 with self.assertRaisesRegex(TypeError, 'errors must be a string, not 9'):
3034 class ThirdFailedStrEnum(StrEnum):
3035 one = '1'
3036 two = b'2', 'ascii', 9
3037
3038 def test_custom_strenum(self):
3039 class CustomStrEnum(str, Enum):
3040 pass
3041 class OkayEnum(CustomStrEnum):
3042 one = '1'
3043 two = '2'
3044 three = b'3', 'ascii'
3045 four = b'4', 'latin1', 'strict'
3046 self.assertEqual(OkayEnum.one, '1')
3047 self.assertEqual(str(OkayEnum.one), 'OkayEnum.one')
3048 self.assertEqual('{}'.format(OkayEnum.one), 'OkayEnum.one')
3049 self.assertEqual(repr(OkayEnum.one), "<OkayEnum.one: '1'>")
3050 #
3051 class DumbMixin:
3052 def __str__(self):
3053 return "don't do this"
3054 class DumbStrEnum(DumbMixin, CustomStrEnum):
3055 five = '5'
3056 six = '6'
3057 seven = '7'
3058 __str__ = DumbMixin.__str__ # needed as of 3.11
3059 self.assertEqual(DumbStrEnum.seven, '7')
3060 self.assertEqual(str(DumbStrEnum.seven), "don't do this")
3061 #
3062 class EnumMixin(Enum):
3063 def hello(self):
3064 print('hello from %s' % (self, ))
3065 class HelloEnum(EnumMixin, CustomStrEnum):
3066 eight = '8'
3067 self.assertEqual(HelloEnum.eight, '8')
3068 self.assertEqual(str(HelloEnum.eight), 'HelloEnum.eight')
3069 #
3070 class GoodbyeMixin:
3071 def goodbye(self):
3072 print('%s wishes you a fond farewell')
3073 class GoodbyeEnum(GoodbyeMixin, EnumMixin, CustomStrEnum):
3074 nine = '9'
3075 self.assertEqual(GoodbyeEnum.nine, '9')
3076 self.assertEqual(str(GoodbyeEnum.nine), 'GoodbyeEnum.nine')
3077 #
3078 class FirstFailedStrEnum(CustomStrEnum):
3079 one = 1 # this will become '1'
3080 two = '2'
3081 class SecondFailedStrEnum(CustomStrEnum):
3082 one = '1'
3083 two = 2, # this will become '2'
3084 three = '3'
3085 class ThirdFailedStrEnum(CustomStrEnum):
3086 one = '1'
3087 two = 2 # this will become '2'
3088 with self.assertRaisesRegex(TypeError,
3089 r"argument (2|'encoding') must be str, not "):
3090 class ThirdFailedStrEnum(CustomStrEnum):
3091 one = '1'
3092 two = b'2', sys.getdefaultencoding
3093 with self.assertRaisesRegex(TypeError,
3094 r"argument (3|'errors') must be str, not "):
3095 class ThirdFailedStrEnum(CustomStrEnum):
3096 one = '1'
3097 two = b'2', 'ascii', 9
3098
3099 def test_missing_value_error(self):
3100 with self.assertRaisesRegex(TypeError, "_value_ not set in __new__"):
3101 class Combined(str, Enum):
3102 #
3103 def __new__(cls, value, sequence):
3104 enum = str.__new__(cls, value)
3105 if '(' in value:
3106 fis_name, segment = value.split('(', 1)
3107 segment = segment.strip(' )')
3108 else:
3109 fis_name = value
3110 segment = None
3111 enum.fis_name = fis_name
3112 enum.segment = segment
3113 enum.sequence = sequence
3114 return enum
3115 #
3116 def __repr__(self):
3117 return "<%s.%s>" % (self.__class__.__name__, self._name_)
3118 #
3119 key_type = 'An$(1,2)', 0
3120 company_id = 'An$(3,2)', 1
3121 code = 'An$(5,1)', 2
3122 description = 'Bn$', 3
3123
3124
3125 def test_private_variable_is_normal_attribute(self):
3126 class Private(Enum):
3127 __corporal = 'Radar'
3128 __major_ = 'Hoolihan'
3129 self.assertEqual(Private._Private__corporal, 'Radar')
3130 self.assertEqual(Private._Private__major_, 'Hoolihan')
3131
3132 def test_member_from_member_access(self):
3133 class Di(Enum):
3134 YES = 1
3135 NO = 0
3136 name = 3
3137 warn = Di.YES.NO
3138 self.assertIs(warn, Di.NO)
3139 self.assertIs(Di.name, Di['name'])
3140 self.assertEqual(Di.name.name, 'name')
3141
3142 def test_dynamic_members_with_static_methods(self):
3143 #
3144 foo_defines = {'FOO_CAT': 'aloof', 'BAR_DOG': 'friendly', 'FOO_HORSE': 'big'}
3145 class Foo(Enum):
3146 vars().update({
3147 k: v
3148 for k, v in foo_defines.items()
3149 if k.startswith('FOO_')
3150 })
3151 def upper(self):
3152 return self.value.upper()
3153 self.assertEqual(list(Foo), [Foo.FOO_CAT, Foo.FOO_HORSE])
3154 self.assertEqual(Foo.FOO_CAT.value, 'aloof')
3155 self.assertEqual(Foo.FOO_HORSE.upper(), 'BIG')
3156 #
3157 with self.assertRaisesRegex(TypeError, "'FOO_CAT' already defined as 'aloof'"):
3158 class FooBar(Enum):
3159 vars().update({
3160 k: v
3161 for k, v in foo_defines.items()
3162 if k.startswith('FOO_')
3163 },
3164 **{'FOO_CAT': 'small'},
3165 )
3166 def upper(self):
3167 return self.value.upper()
3168
3169 def test_repr_with_dataclass(self):
3170 "ensure dataclass-mixin has correct repr()"
3171 #
3172 # check overridden dataclass __repr__ is used
3173 #
3174 from dataclasses import dataclass, field
3175 @dataclass(repr=False)
3176 class Foo:
3177 __qualname__ = 'Foo'
3178 a: int
3179 def __repr__(self):
3180 return 'ha hah!'
3181 class Entries(Foo, Enum):
3182 ENTRY1 = 1
3183 self.assertEqual(repr(Entries.ENTRY1), '<Entries.ENTRY1: ha hah!>')
3184 self.assertTrue(Entries.ENTRY1.value == Foo(1), Entries.ENTRY1.value)
3185 self.assertTrue(isinstance(Entries.ENTRY1, Foo))
3186 self.assertTrue(Entries._member_type_ is Foo, Entries._member_type_)
3187 #
3188 # check auto-generated dataclass __repr__ is not used
3189 #
3190 @dataclass
3191 class CreatureDataMixin:
3192 __qualname__ = 'CreatureDataMixin'
3193 size: str
3194 legs: int
3195 tail: bool = field(repr=False, default=True)
3196 class Creature(CreatureDataMixin, Enum):
3197 __qualname__ = 'Creature'
3198 BEETLE = ('small', 6)
3199 DOG = ('medium', 4)
3200 self.assertEqual(repr(Creature.DOG), "<Creature.DOG: size='medium', legs=4>")
3201 #
3202 # check inherited repr used
3203 #
3204 class Huh:
3205 def __repr__(self):
3206 return 'inherited'
3207 @dataclass(repr=False)
3208 class CreatureDataMixin(Huh):
3209 __qualname__ = 'CreatureDataMixin'
3210 size: str
3211 legs: int
3212 tail: bool = field(repr=False, default=True)
3213 class Creature(CreatureDataMixin, Enum):
3214 __qualname__ = 'Creature'
3215 BEETLE = ('small', 6)
3216 DOG = ('medium', 4)
3217 self.assertEqual(repr(Creature.DOG), "<Creature.DOG: inherited>")
3218 #
3219 # check default object.__repr__ used if nothing provided
3220 #
3221 @dataclass(repr=False)
3222 class CreatureDataMixin:
3223 __qualname__ = 'CreatureDataMixin'
3224 size: str
3225 legs: int
3226 tail: bool = field(repr=False, default=True)
3227 class Creature(CreatureDataMixin, Enum):
3228 __qualname__ = 'Creature'
3229 BEETLE = ('small', 6)
3230 DOG = ('medium', 4)
3231 self.assertRegex(repr(Creature.DOG), "<Creature.DOG: .*CreatureDataMixin object at .*>")
3232
3233 def test_repr_with_init_mixin(self):
3234 class Foo:
3235 def __init__(self, a):
3236 self.a = a
3237 def __repr__(self):
3238 return f'Foo(a={self.a!r})'
3239 class Entries(Foo, Enum):
3240 ENTRY1 = 1
3241 #
3242 self.assertEqual(repr(Entries.ENTRY1), 'Foo(a=1)')
3243
3244 def test_repr_and_str_with_no_init_mixin(self):
3245 # non-data_type is a mixin that doesn't define __new__
3246 class Foo:
3247 def __repr__(self):
3248 return 'Foo'
3249 def __str__(self):
3250 return 'ooF'
3251 class Entries(Foo, Enum):
3252 ENTRY1 = 1
3253 #
3254 self.assertEqual(repr(Entries.ENTRY1), 'Foo')
3255 self.assertEqual(str(Entries.ENTRY1), 'ooF')
3256
3257 def test_value_backup_assign(self):
3258 # check that enum will add missing values when custom __new__ does not
3259 class Some(Enum):
3260 def __new__(cls, val):
3261 return object.__new__(cls)
3262 x = 1
3263 y = 2
3264 self.assertEqual(Some.x.value, 1)
3265 self.assertEqual(Some.y.value, 2)
3266
3267 def test_custom_flag_bitwise(self):
3268 class MyIntFlag(int, Flag):
3269 ONE = 1
3270 TWO = 2
3271 FOUR = 4
3272 self.assertTrue(isinstance(MyIntFlag.ONE | MyIntFlag.TWO, MyIntFlag), MyIntFlag.ONE | MyIntFlag.TWO)
3273 self.assertTrue(isinstance(MyIntFlag.ONE | 2, MyIntFlag))
3274
3275 def test_int_flags_copy(self):
3276 class MyIntFlag(IntFlag):
3277 ONE = 1
3278 TWO = 2
3279 FOUR = 4
3280
3281 flags = MyIntFlag.ONE | MyIntFlag.TWO
3282 copied = copy.copy(flags)
3283 deep = copy.deepcopy(flags)
3284 self.assertEqual(copied, flags)
3285 self.assertEqual(deep, flags)
3286
3287 flags = MyIntFlag.ONE | MyIntFlag.TWO | 8
3288 copied = copy.copy(flags)
3289 deep = copy.deepcopy(flags)
3290 self.assertEqual(copied, flags)
3291 self.assertEqual(deep, flags)
3292 self.assertEqual(copied.value, 1 | 2 | 8)
3293
3294 def test_namedtuple_as_value(self):
3295 from collections import namedtuple
3296 TTuple = namedtuple('TTuple', 'id a blist')
3297 class NTEnum(Enum):
3298 NONE = TTuple(0, 0, [])
3299 A = TTuple(1, 2, [4])
3300 B = TTuple(2, 4, [0, 1, 2])
3301 self.assertEqual(repr(NTEnum.NONE), "<NTEnum.NONE: TTuple(id=0, a=0, blist=[])>")
3302 self.assertEqual(NTEnum.NONE.value, TTuple(id=0, a=0, blist=[]))
3303 self.assertEqual(
3304 [x.value for x in NTEnum],
3305 [TTuple(id=0, a=0, blist=[]), TTuple(id=1, a=2, blist=[4]), TTuple(id=2, a=4, blist=[0, 1, 2])],
3306 )
3307
3308 self.assertRaises(AttributeError, getattr, NTEnum.NONE, 'id')
3309 #
3310 class NTCEnum(TTuple, Enum):
3311 NONE = 0, 0, []
3312 A = 1, 2, [4]
3313 B = 2, 4, [0, 1, 2]
3314 self.assertEqual(repr(NTCEnum.NONE), "<NTCEnum.NONE: TTuple(id=0, a=0, blist=[])>")
3315 self.assertEqual(NTCEnum.NONE.value, TTuple(id=0, a=0, blist=[]))
3316 self.assertEqual(NTCEnum.NONE.id, 0)
3317 self.assertEqual(NTCEnum.A.a, 2)
3318 self.assertEqual(NTCEnum.B.blist, [0, 1 ,2])
3319 self.assertEqual(
3320 [x.value for x in NTCEnum],
3321 [TTuple(id=0, a=0, blist=[]), TTuple(id=1, a=2, blist=[4]), TTuple(id=2, a=4, blist=[0, 1, 2])],
3322 )
3323 #
3324 class NTDEnum(Enum):
3325 def __new__(cls, id, a, blist):
3326 member = object.__new__(cls)
3327 member.id = id
3328 member.a = a
3329 member.blist = blist
3330 return member
3331 NONE = TTuple(0, 0, [])
3332 A = TTuple(1, 2, [4])
3333 B = TTuple(2, 4, [0, 1, 2])
3334 self.assertEqual(repr(NTDEnum.NONE), "<NTDEnum.NONE: TTuple(id=0, a=0, blist=[])>")
3335 self.assertEqual(NTDEnum.NONE.id, 0)
3336 self.assertEqual(NTDEnum.A.a, 2)
3337 self.assertEqual(NTDEnum.B.blist, [0, 1 ,2])
3338
3339 def test_flag_with_custom_new(self):
3340 class FlagFromChar(IntFlag):
3341 def __new__(cls, c):
3342 value = 1 << c
3343 self = int.__new__(cls, value)
3344 self._value_ = value
3345 return self
3346 #
3347 a = ord('a')
3348 #
3349 self.assertEqual(FlagFromChar._all_bits_, 316912650057057350374175801343)
3350 self.assertEqual(FlagFromChar._flag_mask_, 158456325028528675187087900672)
3351 self.assertEqual(FlagFromChar.a, 158456325028528675187087900672)
3352 self.assertEqual(FlagFromChar.a|1, 158456325028528675187087900673)
3353 #
3354 #
3355 class FlagFromChar(Flag):
3356 def __new__(cls, c):
3357 value = 1 << c
3358 self = object.__new__(cls)
3359 self._value_ = value
3360 return self
3361 #
3362 a = ord('a')
3363 z = 1
3364 #
3365 self.assertEqual(FlagFromChar._all_bits_, 316912650057057350374175801343)
3366 self.assertEqual(FlagFromChar._flag_mask_, 158456325028528675187087900674)
3367 self.assertEqual(FlagFromChar.a.value, 158456325028528675187087900672)
3368 self.assertEqual((FlagFromChar.a|FlagFromChar.z).value, 158456325028528675187087900674)
3369 #
3370 #
3371 class FlagFromChar(int, Flag, boundary=KEEP):
3372 def __new__(cls, c):
3373 value = 1 << c
3374 self = int.__new__(cls, value)
3375 self._value_ = value
3376 return self
3377 #
3378 a = ord('a')
3379 #
3380 self.assertEqual(FlagFromChar._all_bits_, 316912650057057350374175801343)
3381 self.assertEqual(FlagFromChar._flag_mask_, 158456325028528675187087900672)
3382 self.assertEqual(FlagFromChar.a, 158456325028528675187087900672)
3383 self.assertEqual(FlagFromChar.a|1, 158456325028528675187087900673)
3384
3385 def test_init_exception(self):
3386 class Base:
3387 def __new__(cls, *args):
3388 return object.__new__(cls)
3389 def __init__(self, x):
3390 raise ValueError("I don't like", x)
3391 with self.assertRaises(TypeError):
3392 class MyEnum(Base, enum.Enum):
3393 A = 'a'
3394 def __init__(self, y):
3395 self.y = y
3396 with self.assertRaises(ValueError):
3397 class MyEnum(Base, enum.Enum):
3398 A = 'a'
3399 def __init__(self, y):
3400 self.y = y
3401 def __new__(cls, value):
3402 member = Base.__new__(cls)
3403 member._value_ = Base(value)
3404 return member
3405
3406 def test_extra_member_creation(self):
3407 class IDEnumMeta(EnumMeta):
3408 def __new__(metacls, cls, bases, classdict, **kwds):
3409 # add new entries to classdict
3410 for name in classdict.member_names:
3411 classdict[f'{name}_DESC'] = f'-{classdict[name]}'
3412 return super().__new__(metacls, cls, bases, classdict, **kwds)
3413 class IDEnum(StrEnum, metaclass=IDEnumMeta):
3414 pass
3415 class MyEnum(IDEnum):
3416 ID = 'id'
3417 NAME = 'name'
3418 self.assertEqual(list(MyEnum), [MyEnum.ID, MyEnum.NAME, MyEnum.ID_DESC, MyEnum.NAME_DESC])
3419
3420 def test_add_alias(self):
3421 class mixin:
3422 @property
3423 def ORG(self):
3424 return 'huh'
3425 class Color(mixin, Enum):
3426 RED = 1
3427 GREEN = 2
3428 BLUE = 3
3429 Color.RED._add_alias_('ROJO')
3430 self.assertIs(Color.RED, Color['ROJO'])
3431 self.assertIs(Color.RED, Color.ROJO)
3432 Color.BLUE._add_alias_('ORG')
3433 self.assertIs(Color.BLUE, Color['ORG'])
3434 self.assertIs(Color.BLUE, Color.ORG)
3435 self.assertEqual(Color.RED.ORG, 'huh')
3436 self.assertEqual(Color.GREEN.ORG, 'huh')
3437 self.assertEqual(Color.BLUE.ORG, 'huh')
3438 self.assertEqual(Color.ORG.ORG, 'huh')
3439
3440 def test_add_value_alias_after_creation(self):
3441 class Color(Enum):
3442 RED = 1
3443 GREEN = 2
3444 BLUE = 3
3445 Color.RED._add_value_alias_(5)
3446 self.assertIs(Color.RED, Color(5))
3447
3448 def test_add_value_alias_during_creation(self):
3449 class Types(Enum):
3450 Unknown = 0,
3451 Source = 1, 'src'
3452 NetList = 2, 'nl'
3453 def __new__(cls, int_value, *value_aliases):
3454 member = object.__new__(cls)
3455 member._value_ = int_value
3456 for alias in value_aliases:
3457 member._add_value_alias_(alias)
3458 return member
3459 self.assertIs(Types(0), Types.Unknown)
3460 self.assertIs(Types(1), Types.Source)
3461 self.assertIs(Types('src'), Types.Source)
3462 self.assertIs(Types(2), Types.NetList)
3463 self.assertIs(Types('nl'), Types.NetList)
3464
3465 def test_second_tuple_item_is_falsey(self):
3466 class Cardinal(Enum):
3467 RIGHT = (1, 0)
3468 UP = (0, 1)
3469 LEFT = (-1, 0)
3470 DOWN = (0, -1)
3471 self.assertIs(Cardinal(1, 0), Cardinal.RIGHT)
3472 self.assertIs(Cardinal(-1, 0), Cardinal.LEFT)
3473
3474 def test_no_members(self):
3475 with self.assertRaisesRegex(
3476 TypeError,
3477 'has no members',
3478 ):
3479 Enum(7)
3480 with self.assertRaisesRegex(
3481 TypeError,
3482 'has no members',
3483 ):
3484 Flag(7)
3485
3486 def test_empty_names(self):
3487 for nothing in '', [], {}:
3488 for e_type in None, int:
3489 empty_enum = Enum('empty_enum', nothing, type=e_type)
3490 self.assertEqual(len(empty_enum), 0)
3491 self.assertRaisesRegex(TypeError, 'has no members', empty_enum, 0)
3492 self.assertRaisesRegex(TypeError, '.int. object is not iterable', Enum, 'bad_enum', names=0)
3493 self.assertRaisesRegex(TypeError, '.int. object is not iterable', Enum, 'bad_enum', 0, type=int)
3494
3495 def test_nonhashable_matches_hashable(self): # issue 125710
3496 class Directions(Enum):
3497 DOWN_ONLY = frozenset({"sc"})
3498 UP_ONLY = frozenset({"cs"})
3499 UNRESTRICTED = frozenset({"sc", "cs"})
3500 self.assertIs(Directions({"sc"}), Directions.DOWN_ONLY)
3501
3502
3503 class TestOrder(unittest.TestCase):
3504 "test usage of the `_order_` attribute"
3505
3506 def test_same_members(self):
3507 class Color(Enum):
3508 _order_ = 'red green blue'
3509 red = 1
3510 green = 2
3511 blue = 3
3512
3513 def test_same_members_with_aliases(self):
3514 class Color(Enum):
3515 _order_ = 'red green blue'
3516 red = 1
3517 green = 2
3518 blue = 3
3519 verde = green
3520
3521 def test_same_members_wrong_order(self):
3522 with self.assertRaisesRegex(TypeError, 'member order does not match _order_'):
3523 class Color(Enum):
3524 _order_ = 'red green blue'
3525 red = 1
3526 blue = 3
3527 green = 2
3528
3529 def test_order_has_extra_members(self):
3530 with self.assertRaisesRegex(TypeError, 'member order does not match _order_'):
3531 class Color(Enum):
3532 _order_ = 'red green blue purple'
3533 red = 1
3534 green = 2
3535 blue = 3
3536
3537 def test_order_has_extra_members_with_aliases(self):
3538 with self.assertRaisesRegex(TypeError, 'member order does not match _order_'):
3539 class Color(Enum):
3540 _order_ = 'red green blue purple'
3541 red = 1
3542 green = 2
3543 blue = 3
3544 verde = green
3545
3546 def test_enum_has_extra_members(self):
3547 with self.assertRaisesRegex(TypeError, 'member order does not match _order_'):
3548 class Color(Enum):
3549 _order_ = 'red green blue'
3550 red = 1
3551 green = 2
3552 blue = 3
3553 purple = 4
3554
3555 def test_enum_has_extra_members_with_aliases(self):
3556 with self.assertRaisesRegex(TypeError, 'member order does not match _order_'):
3557 class Color(Enum):
3558 _order_ = 'red green blue'
3559 red = 1
3560 green = 2
3561 blue = 3
3562 purple = 4
3563 verde = green
3564
3565
3566 class OldTestFlag(unittest.TestCase):
3567 """Tests of the Flags."""
3568
3569 class Perm(Flag):
3570 R, W, X = 4, 2, 1
3571
3572 class Open(Flag):
3573 RO = 0
3574 WO = 1
3575 RW = 2
3576 AC = 3
3577 CE = 1<<19
3578
3579 class Color(Flag):
3580 BLACK = 0
3581 RED = 1
3582 ROJO = 1
3583 GREEN = 2
3584 BLUE = 4
3585 PURPLE = RED|BLUE
3586 WHITE = RED|GREEN|BLUE
3587 BLANCO = RED|GREEN|BLUE
3588
3589 def test_or(self):
3590 Perm = self.Perm
3591 for i in Perm:
3592 for j in Perm:
3593 self.assertEqual((i | j), Perm(i.value | j.value))
3594 self.assertEqual((i | j).value, i.value | j.value)
3595 self.assertIs(type(i | j), Perm)
3596 for i in Perm:
3597 self.assertIs(i | i, i)
3598 Open = self.Open
3599 self.assertIs(Open.RO | Open.CE, Open.CE)
3600
3601 def test_and(self):
3602 Perm = self.Perm
3603 RW = Perm.R | Perm.W
3604 RX = Perm.R | Perm.X
3605 WX = Perm.W | Perm.X
3606 RWX = Perm.R | Perm.W | Perm.X
3607 values = list(Perm) + [RW, RX, WX, RWX, Perm(0)]
3608 for i in values:
3609 for j in values:
3610 self.assertEqual((i & j).value, i.value & j.value)
3611 self.assertIs(type(i & j), Perm)
3612 for i in Perm:
3613 self.assertIs(i & i, i)
3614 self.assertIs(i & RWX, i)
3615 self.assertIs(RWX & i, i)
3616 Open = self.Open
3617 self.assertIs(Open.RO & Open.CE, Open.RO)
3618
3619 def test_xor(self):
3620 Perm = self.Perm
3621 for i in Perm:
3622 for j in Perm:
3623 self.assertEqual((i ^ j).value, i.value ^ j.value)
3624 self.assertIs(type(i ^ j), Perm)
3625 for i in Perm:
3626 self.assertIs(i ^ Perm(0), i)
3627 self.assertIs(Perm(0) ^ i, i)
3628 Open = self.Open
3629 self.assertIs(Open.RO ^ Open.CE, Open.CE)
3630 self.assertIs(Open.CE ^ Open.CE, Open.RO)
3631
3632 def test_bool(self):
3633 Perm = self.Perm
3634 for f in Perm:
3635 self.assertTrue(f)
3636 Open = self.Open
3637 for f in Open:
3638 self.assertEqual(bool(f.value), bool(f))
3639
3640 def test_boundary(self):
3641 self.assertIs(enum.Flag._boundary_, STRICT)
3642 class Iron(Flag, boundary=CONFORM):
3643 ONE = 1
3644 TWO = 2
3645 EIGHT = 8
3646 self.assertIs(Iron._boundary_, CONFORM)
3647 #
3648 class Water(Flag, boundary=STRICT):
3649 ONE = 1
3650 TWO = 2
3651 EIGHT = 8
3652 self.assertIs(Water._boundary_, STRICT)
3653 #
3654 class Space(Flag, boundary=EJECT):
3655 ONE = 1
3656 TWO = 2
3657 EIGHT = 8
3658 self.assertIs(Space._boundary_, EJECT)
3659 #
3660 class Bizarre(Flag, boundary=KEEP):
3661 b = 3
3662 c = 4
3663 d = 6
3664 #
3665 self.assertRaisesRegex(ValueError, 'invalid value 7', Water, 7)
3666 #
3667 self.assertIs(Iron(7), Iron.ONE|Iron.TWO)
3668 self.assertIs(Iron(~9), Iron.TWO)
3669 #
3670 self.assertEqual(Space(7), 7)
3671 self.assertTrue(type(Space(7)) is int)
3672 #
3673 self.assertEqual(list(Bizarre), [Bizarre.c])
3674 self.assertIs(Bizarre(3), Bizarre.b)
3675 self.assertIs(Bizarre(6), Bizarre.d)
3676 #
3677 class SkipFlag(enum.Flag):
3678 A = 1
3679 B = 2
3680 C = 4 | B
3681 #
3682 self.assertTrue(SkipFlag.C in (SkipFlag.A|SkipFlag.C))
3683 self.assertRaisesRegex(ValueError, 'SkipFlag.. invalid value 42', SkipFlag, 42)
3684 #
3685 class SkipIntFlag(enum.IntFlag):
3686 A = 1
3687 B = 2
3688 C = 4 | B
3689 #
3690 self.assertTrue(SkipIntFlag.C in (SkipIntFlag.A|SkipIntFlag.C))
3691 self.assertEqual(SkipIntFlag(42).value, 42)
3692 #
3693 class MethodHint(Flag):
3694 HiddenText = 0x10
3695 DigitsOnly = 0x01
3696 LettersOnly = 0x02
3697 OnlyMask = 0x0f
3698 #
3699 self.assertEqual(str(MethodHint.HiddenText|MethodHint.OnlyMask), 'MethodHint.HiddenText|DigitsOnly|LettersOnly|OnlyMask')
3700
3701
3702 def test_iter(self):
3703 Color = self.Color
3704 Open = self.Open
3705 self.assertEqual(list(Color), [Color.RED, Color.GREEN, Color.BLUE])
3706 self.assertEqual(list(Open), [Open.WO, Open.RW, Open.CE])
3707
3708 def test_programatic_function_string(self):
3709 Perm = Flag('Perm', 'R W X')
3710 lst = list(Perm)
3711 self.assertEqual(len(lst), len(Perm))
3712 self.assertEqual(len(Perm), 3, Perm)
3713 self.assertEqual(lst, [Perm.R, Perm.W, Perm.X])
3714 for i, n in enumerate('R W X'.split()):
3715 v = 1<<i
3716 e = Perm(v)
3717 self.assertEqual(e.value, v)
3718 self.assertEqual(type(e.value), int)
3719 self.assertEqual(e.name, n)
3720 self.assertIn(e, Perm)
3721 self.assertIs(type(e), Perm)
3722
3723 def test_programatic_function_string_with_start(self):
3724 Perm = Flag('Perm', 'R W X', start=8)
3725 lst = list(Perm)
3726 self.assertEqual(len(lst), len(Perm))
3727 self.assertEqual(len(Perm), 3, Perm)
3728 self.assertEqual(lst, [Perm.R, Perm.W, Perm.X])
3729 for i, n in enumerate('R W X'.split()):
3730 v = 8<<i
3731 e = Perm(v)
3732 self.assertEqual(e.value, v)
3733 self.assertEqual(type(e.value), int)
3734 self.assertEqual(e.name, n)
3735 self.assertIn(e, Perm)
3736 self.assertIs(type(e), Perm)
3737
3738 def test_programatic_function_string_list(self):
3739 Perm = Flag('Perm', ['R', 'W', 'X'])
3740 lst = list(Perm)
3741 self.assertEqual(len(lst), len(Perm))
3742 self.assertEqual(len(Perm), 3, Perm)
3743 self.assertEqual(lst, [Perm.R, Perm.W, Perm.X])
3744 for i, n in enumerate('R W X'.split()):
3745 v = 1<<i
3746 e = Perm(v)
3747 self.assertEqual(e.value, v)
3748 self.assertEqual(type(e.value), int)
3749 self.assertEqual(e.name, n)
3750 self.assertIn(e, Perm)
3751 self.assertIs(type(e), Perm)
3752
3753 def test_programatic_function_iterable(self):
3754 Perm = Flag('Perm', (('R', 2), ('W', 8), ('X', 32)))
3755 lst = list(Perm)
3756 self.assertEqual(len(lst), len(Perm))
3757 self.assertEqual(len(Perm), 3, Perm)
3758 self.assertEqual(lst, [Perm.R, Perm.W, Perm.X])
3759 for i, n in enumerate('R W X'.split()):
3760 v = 1<<(2*i+1)
3761 e = Perm(v)
3762 self.assertEqual(e.value, v)
3763 self.assertEqual(type(e.value), int)
3764 self.assertEqual(e.name, n)
3765 self.assertIn(e, Perm)
3766 self.assertIs(type(e), Perm)
3767
3768 def test_programatic_function_from_dict(self):
3769 Perm = Flag('Perm', OrderedDict((('R', 2), ('W', 8), ('X', 32))))
3770 lst = list(Perm)
3771 self.assertEqual(len(lst), len(Perm))
3772 self.assertEqual(len(Perm), 3, Perm)
3773 self.assertEqual(lst, [Perm.R, Perm.W, Perm.X])
3774 for i, n in enumerate('R W X'.split()):
3775 v = 1<<(2*i+1)
3776 e = Perm(v)
3777 self.assertEqual(e.value, v)
3778 self.assertEqual(type(e.value), int)
3779 self.assertEqual(e.name, n)
3780 self.assertIn(e, Perm)
3781 self.assertIs(type(e), Perm)
3782
3783 @reraise_if_not_enum(
3784 FlagStooges,
3785 FlagStoogesWithZero,
3786 IntFlagStooges,
3787 IntFlagStoogesWithZero,
3788 )
3789 def test_pickle(self):
3790 test_pickle_dump_load(self.assertIs, FlagStooges.CURLY)
3791 test_pickle_dump_load(self.assertEqual,
3792 FlagStooges.CURLY|FlagStooges.MOE)
3793 test_pickle_dump_load(self.assertEqual,
3794 FlagStooges.CURLY&~FlagStooges.CURLY)
3795 test_pickle_dump_load(self.assertIs, FlagStooges)
3796 test_pickle_dump_load(self.assertEqual, FlagStooges.BIG)
3797 test_pickle_dump_load(self.assertEqual,
3798 FlagStooges.CURLY|FlagStooges.BIG)
3799
3800 test_pickle_dump_load(self.assertIs, FlagStoogesWithZero.CURLY)
3801 test_pickle_dump_load(self.assertEqual,
3802 FlagStoogesWithZero.CURLY|FlagStoogesWithZero.MOE)
3803 test_pickle_dump_load(self.assertIs, FlagStoogesWithZero.NOFLAG)
3804 test_pickle_dump_load(self.assertEqual, FlagStoogesWithZero.BIG)
3805 test_pickle_dump_load(self.assertEqual,
3806 FlagStoogesWithZero.CURLY|FlagStoogesWithZero.BIG)
3807
3808 test_pickle_dump_load(self.assertIs, IntFlagStooges.CURLY)
3809 test_pickle_dump_load(self.assertEqual,
3810 IntFlagStooges.CURLY|IntFlagStooges.MOE)
3811 test_pickle_dump_load(self.assertEqual,
3812 IntFlagStooges.CURLY|IntFlagStooges.MOE|0x30)
3813 test_pickle_dump_load(self.assertEqual, IntFlagStooges(0))
3814 test_pickle_dump_load(self.assertEqual, IntFlagStooges(0x30))
3815 test_pickle_dump_load(self.assertIs, IntFlagStooges)
3816 test_pickle_dump_load(self.assertEqual, IntFlagStooges.BIG)
3817 test_pickle_dump_load(self.assertEqual, IntFlagStooges.BIG|1)
3818 test_pickle_dump_load(self.assertEqual,
3819 IntFlagStooges.CURLY|IntFlagStooges.BIG)
3820
3821 test_pickle_dump_load(self.assertIs, IntFlagStoogesWithZero.CURLY)
3822 test_pickle_dump_load(self.assertEqual,
3823 IntFlagStoogesWithZero.CURLY|IntFlagStoogesWithZero.MOE)
3824 test_pickle_dump_load(self.assertIs, IntFlagStoogesWithZero.NOFLAG)
3825 test_pickle_dump_load(self.assertEqual, IntFlagStoogesWithZero.BIG)
3826 test_pickle_dump_load(self.assertEqual, IntFlagStoogesWithZero.BIG|1)
3827 test_pickle_dump_load(self.assertEqual,
3828 IntFlagStoogesWithZero.CURLY|IntFlagStoogesWithZero.BIG)
3829
3830 def test_contains_tf(self):
3831 Open = self.Open
3832 Color = self.Color
3833 self.assertFalse(Color.BLACK in Open)
3834 self.assertFalse(Open.RO in Color)
3835 self.assertFalse('BLACK' in Color)
3836 self.assertFalse('RO' in Open)
3837 self.assertTrue(Color.BLACK in Color)
3838 self.assertTrue(Open.RO in Open)
3839 self.assertTrue(1 in Color)
3840 self.assertTrue(1 in Open)
3841
3842 def test_member_contains(self):
3843 Perm = self.Perm
3844 R, W, X = Perm
3845 RW = R | W
3846 RX = R | X
3847 WX = W | X
3848 RWX = R | W | X
3849 self.assertTrue(R in RW)
3850 self.assertTrue(R in RX)
3851 self.assertTrue(R in RWX)
3852 self.assertTrue(W in RW)
3853 self.assertTrue(W in WX)
3854 self.assertTrue(W in RWX)
3855 self.assertTrue(X in RX)
3856 self.assertTrue(X in WX)
3857 self.assertTrue(X in RWX)
3858 self.assertFalse(R in WX)
3859 self.assertFalse(W in RX)
3860 self.assertFalse(X in RW)
3861
3862 def test_member_iter(self):
3863 Color = self.Color
3864 self.assertEqual(list(Color.BLACK), [])
3865 self.assertEqual(list(Color.PURPLE), [Color.RED, Color.BLUE])
3866 self.assertEqual(list(Color.BLUE), [Color.BLUE])
3867 self.assertEqual(list(Color.GREEN), [Color.GREEN])
3868 self.assertEqual(list(Color.WHITE), [Color.RED, Color.GREEN, Color.BLUE])
3869 self.assertEqual(list(Color.WHITE), [Color.RED, Color.GREEN, Color.BLUE])
3870
3871 def test_member_length(self):
3872 self.assertEqual(self.Color.__len__(self.Color.BLACK), 0)
3873 self.assertEqual(self.Color.__len__(self.Color.GREEN), 1)
3874 self.assertEqual(self.Color.__len__(self.Color.PURPLE), 2)
3875 self.assertEqual(self.Color.__len__(self.Color.BLANCO), 3)
3876
3877 def test_number_reset_and_order_cleanup(self):
3878 class Confused(Flag):
3879 _order_ = 'ONE TWO FOUR DOS EIGHT SIXTEEN'
3880 ONE = auto()
3881 TWO = auto()
3882 FOUR = auto()
3883 DOS = 2
3884 EIGHT = auto()
3885 SIXTEEN = auto()
3886 self.assertEqual(
3887 list(Confused),
3888 [Confused.ONE, Confused.TWO, Confused.FOUR, Confused.EIGHT, Confused.SIXTEEN])
3889 self.assertIs(Confused.TWO, Confused.DOS)
3890 self.assertEqual(Confused.DOS._value_, 2)
3891 self.assertEqual(Confused.EIGHT._value_, 8)
3892 self.assertEqual(Confused.SIXTEEN._value_, 16)
3893
3894 def test_aliases(self):
3895 Color = self.Color
3896 self.assertEqual(Color(1).name, 'RED')
3897 self.assertEqual(Color['ROJO'].name, 'RED')
3898 self.assertEqual(Color(7).name, 'WHITE')
3899 self.assertEqual(Color['BLANCO'].name, 'WHITE')
3900 self.assertIs(Color.BLANCO, Color.WHITE)
3901 Open = self.Open
3902 self.assertIs(Open['AC'], Open.AC)
3903
3904 def test_auto_number(self):
3905 class Color(Flag):
3906 red = auto()
3907 blue = auto()
3908 green = auto()
3909
3910 self.assertEqual(list(Color), [Color.red, Color.blue, Color.green])
3911 self.assertEqual(Color.red.value, 1)
3912 self.assertEqual(Color.blue.value, 2)
3913 self.assertEqual(Color.green.value, 4)
3914
3915 def test_auto_number_garbage(self):
3916 with self.assertRaisesRegex(TypeError, 'invalid flag value .not an int.'):
3917 class Color(Flag):
3918 red = 'not an int'
3919 blue = auto()
3920
3921 def test_duplicate_auto(self):
3922 class Dupes(Enum):
3923 first = primero = auto()
3924 second = auto()
3925 third = auto()
3926 self.assertEqual([Dupes.first, Dupes.second, Dupes.third], list(Dupes))
3927
3928 def test_multiple_mixin(self):
3929 class AllMixin:
3930 @classproperty
3931 def ALL(cls):
3932 members = list(cls)
3933 all_value = None
3934 if members:
3935 all_value = members[0]
3936 for member in members[1:]:
3937 all_value |= member
3938 cls.ALL = all_value
3939 return all_value
3940 class StrMixin:
3941 def __str__(self):
3942 return self._name_.lower()
3943 class Color(AllMixin, Flag):
3944 RED = auto()
3945 GREEN = auto()
3946 BLUE = auto()
3947 self.assertEqual(Color.RED.value, 1)
3948 self.assertEqual(Color.GREEN.value, 2)
3949 self.assertEqual(Color.BLUE.value, 4)
3950 self.assertEqual(Color.ALL.value, 7)
3951 self.assertEqual(str(Color.BLUE), 'Color.BLUE')
3952 class Color(AllMixin, StrMixin, Flag):
3953 RED = auto()
3954 GREEN = auto()
3955 BLUE = auto()
3956 __str__ = StrMixin.__str__
3957 self.assertEqual(Color.RED.value, 1)
3958 self.assertEqual(Color.GREEN.value, 2)
3959 self.assertEqual(Color.BLUE.value, 4)
3960 self.assertEqual(Color.ALL.value, 7)
3961 self.assertEqual(str(Color.BLUE), 'blue')
3962 class Color(StrMixin, AllMixin, Flag):
3963 RED = auto()
3964 GREEN = auto()
3965 BLUE = auto()
3966 __str__ = StrMixin.__str__
3967 self.assertEqual(Color.RED.value, 1)
3968 self.assertEqual(Color.GREEN.value, 2)
3969 self.assertEqual(Color.BLUE.value, 4)
3970 self.assertEqual(Color.ALL.value, 7)
3971 self.assertEqual(str(Color.BLUE), 'blue')
3972
3973 @threading_helper.reap_threads
3974 @threading_helper.requires_working_threading()
3975 def test_unique_composite(self):
3976 # override __eq__ to be identity only
3977 class TestFlag(Flag):
3978 one = auto()
3979 two = auto()
3980 three = auto()
3981 four = auto()
3982 five = auto()
3983 six = auto()
3984 seven = auto()
3985 eight = auto()
3986 def __eq__(self, other):
3987 return self is other
3988 def __hash__(self):
3989 return hash(self._value_)
3990 # have multiple threads competing to complete the composite members
3991 seen = set()
3992 failed = False
3993 def cycle_enum():
3994 nonlocal failed
3995 try:
3996 for i in range(256):
3997 seen.add(TestFlag(i))
3998 except Exception:
3999 failed = True
4000 threads = [
4001 threading.Thread(target=cycle_enum)
4002 for _ in range(8)
4003 ]
4004 with threading_helper.start_threads(threads):
4005 pass
4006 # check that only 248 members were created
4007 self.assertFalse(
4008 failed,
4009 'at least one thread failed while creating composite members')
4010 self.assertEqual(256, len(seen), 'too many composite members created')
4011
4012 def test_init_subclass(self):
4013 class MyEnum(Flag):
4014 def __init_subclass__(cls, **kwds):
4015 super().__init_subclass__(**kwds)
4016 self.assertFalse(cls.__dict__.get('_test', False))
4017 cls._test1 = 'MyEnum'
4018 #
4019 class TheirEnum(MyEnum):
4020 def __init_subclass__(cls, **kwds):
4021 super(TheirEnum, cls).__init_subclass__(**kwds)
4022 cls._test2 = 'TheirEnum'
4023 class WhoseEnum(TheirEnum):
4024 def __init_subclass__(cls, **kwds):
4025 pass
4026 class NoEnum(WhoseEnum):
4027 ONE = 1
4028 self.assertEqual(TheirEnum.__dict__['_test1'], 'MyEnum')
4029 self.assertEqual(WhoseEnum.__dict__['_test1'], 'MyEnum')
4030 self.assertEqual(WhoseEnum.__dict__['_test2'], 'TheirEnum')
4031 self.assertFalse(NoEnum.__dict__.get('_test1', False))
4032 self.assertFalse(NoEnum.__dict__.get('_test2', False))
4033 #
4034 class OurEnum(MyEnum):
4035 def __init_subclass__(cls, **kwds):
4036 cls._test2 = 'OurEnum'
4037 class WhereEnum(OurEnum):
4038 def __init_subclass__(cls, **kwds):
4039 pass
4040 class NeverEnum(WhereEnum):
4041 ONE = 1
4042 self.assertEqual(OurEnum.__dict__['_test1'], 'MyEnum')
4043 self.assertFalse(WhereEnum.__dict__.get('_test1', False))
4044 self.assertEqual(WhereEnum.__dict__['_test2'], 'OurEnum')
4045 self.assertFalse(NeverEnum.__dict__.get('_test1', False))
4046 self.assertFalse(NeverEnum.__dict__.get('_test2', False))
4047
4048
4049 class OldTestIntFlag(unittest.TestCase):
4050 """Tests of the IntFlags."""
4051
4052 class Perm(IntFlag):
4053 R = 1 << 2
4054 W = 1 << 1
4055 X = 1 << 0
4056
4057 class Open(IntFlag):
4058 RO = 0
4059 WO = 1
4060 RW = 2
4061 AC = 3
4062 CE = 1<<19
4063
4064 class Color(IntFlag):
4065 BLACK = 0
4066 RED = 1
4067 ROJO = 1
4068 GREEN = 2
4069 BLUE = 4
4070 PURPLE = RED|BLUE
4071 WHITE = RED|GREEN|BLUE
4072 BLANCO = RED|GREEN|BLUE
4073
4074 class Skip(IntFlag):
4075 FIRST = 1
4076 SECOND = 2
4077 EIGHTH = 8
4078
4079 def test_type(self):
4080 Perm = self.Perm
4081 self.assertTrue(Perm._member_type_ is int)
4082 Open = self.Open
4083 for f in Perm:
4084 self.assertTrue(isinstance(f, Perm))
4085 self.assertEqual(f, f.value)
4086 self.assertTrue(isinstance(Perm.W | Perm.X, Perm))
4087 self.assertEqual(Perm.W | Perm.X, 3)
4088 for f in Open:
4089 self.assertTrue(isinstance(f, Open))
4090 self.assertEqual(f, f.value)
4091 self.assertTrue(isinstance(Open.WO | Open.RW, Open))
4092 self.assertEqual(Open.WO | Open.RW, 3)
4093
4094 @reraise_if_not_enum(HeadlightsK)
4095 def test_global_repr_keep(self):
4096 self.assertEqual(
4097 repr(HeadlightsK(0)),
4098 '%s.OFF_K' % SHORT_MODULE,
4099 )
4100 self.assertEqual(
4101 repr(HeadlightsK(2**0 + 2**2 + 2**3)),
4102 '%(m)s.LOW_BEAM_K|%(m)s.FOG_K|8' % {'m': SHORT_MODULE},
4103 )
4104 self.assertEqual(
4105 repr(HeadlightsK(2**3)),
4106 '%(m)s.HeadlightsK(8)' % {'m': SHORT_MODULE},
4107 )
4108
4109 @reraise_if_not_enum(HeadlightsC)
4110 def test_global_repr_conform1(self):
4111 self.assertEqual(
4112 repr(HeadlightsC(0)),
4113 '%s.OFF_C' % SHORT_MODULE,
4114 )
4115 self.assertEqual(
4116 repr(HeadlightsC(2**0 + 2**2 + 2**3)),
4117 '%(m)s.LOW_BEAM_C|%(m)s.FOG_C' % {'m': SHORT_MODULE},
4118 )
4119 self.assertEqual(
4120 repr(HeadlightsC(2**3)),
4121 '%(m)s.OFF_C' % {'m': SHORT_MODULE},
4122 )
4123
4124 @reraise_if_not_enum(NoName)
4125 def test_global_enum_str(self):
4126 self.assertEqual(repr(NoName.ONE), 'test_enum.ONE')
4127 self.assertEqual(repr(NoName(0)), 'test_enum.NoName(0)')
4128 self.assertEqual(str(NoName.ONE & NoName.TWO), 'NoName(0)')
4129 self.assertEqual(str(NoName(0)), 'NoName(0)')
4130
4131 def test_format(self):
4132 Perm = self.Perm
4133 self.assertEqual(format(Perm.R, ''), '4')
4134 self.assertEqual(format(Perm.R | Perm.X, ''), '5')
4135 #
4136 class NewPerm(IntFlag):
4137 R = 1 << 2
4138 W = 1 << 1
4139 X = 1 << 0
4140 def __str__(self):
4141 return self._name_
4142 self.assertEqual(format(NewPerm.R, ''), 'R')
4143 self.assertEqual(format(NewPerm.R | Perm.X, ''), 'R|X')
4144
4145 def test_or(self):
4146 Perm = self.Perm
4147 for i in Perm:
4148 for j in Perm:
4149 self.assertEqual(i | j, i.value | j.value)
4150 self.assertEqual((i | j).value, i.value | j.value)
4151 self.assertIs(type(i | j), Perm)
4152 for j in range(8):
4153 self.assertEqual(i | j, i.value | j)
4154 self.assertEqual((i | j).value, i.value | j)
4155 self.assertIs(type(i | j), Perm)
4156 self.assertEqual(j | i, j | i.value)
4157 self.assertEqual((j | i).value, j | i.value)
4158 self.assertIs(type(j | i), Perm)
4159 for i in Perm:
4160 self.assertIs(i | i, i)
4161 self.assertIs(i | 0, i)
4162 self.assertIs(0 | i, i)
4163 Open = self.Open
4164 self.assertIs(Open.RO | Open.CE, Open.CE)
4165
4166 def test_and(self):
4167 Perm = self.Perm
4168 RW = Perm.R | Perm.W
4169 RX = Perm.R | Perm.X
4170 WX = Perm.W | Perm.X
4171 RWX = Perm.R | Perm.W | Perm.X
4172 values = list(Perm) + [RW, RX, WX, RWX, Perm(0)]
4173 for i in values:
4174 for j in values:
4175 self.assertEqual(i & j, i.value & j.value, 'i is %r, j is %r' % (i, j))
4176 self.assertEqual((i & j).value, i.value & j.value, 'i is %r, j is %r' % (i, j))
4177 self.assertIs(type(i & j), Perm, 'i is %r, j is %r' % (i, j))
4178 for j in range(8):
4179 self.assertEqual(i & j, i.value & j)
4180 self.assertEqual((i & j).value, i.value & j)
4181 self.assertIs(type(i & j), Perm)
4182 self.assertEqual(j & i, j & i.value)
4183 self.assertEqual((j & i).value, j & i.value)
4184 self.assertIs(type(j & i), Perm)
4185 for i in Perm:
4186 self.assertIs(i & i, i)
4187 self.assertIs(i & 7, i)
4188 self.assertIs(7 & i, i)
4189 Open = self.Open
4190 self.assertIs(Open.RO & Open.CE, Open.RO)
4191
4192 def test_xor(self):
4193 Perm = self.Perm
4194 for i in Perm:
4195 for j in Perm:
4196 self.assertEqual(i ^ j, i.value ^ j.value)
4197 self.assertEqual((i ^ j).value, i.value ^ j.value)
4198 self.assertIs(type(i ^ j), Perm)
4199 for j in range(8):
4200 self.assertEqual(i ^ j, i.value ^ j)
4201 self.assertEqual((i ^ j).value, i.value ^ j)
4202 self.assertIs(type(i ^ j), Perm)
4203 self.assertEqual(j ^ i, j ^ i.value)
4204 self.assertEqual((j ^ i).value, j ^ i.value)
4205 self.assertIs(type(j ^ i), Perm)
4206 for i in Perm:
4207 self.assertIs(i ^ 0, i)
4208 self.assertIs(0 ^ i, i)
4209 Open = self.Open
4210 self.assertIs(Open.RO ^ Open.CE, Open.CE)
4211 self.assertIs(Open.CE ^ Open.CE, Open.RO)
4212
4213 def test_invert(self):
4214 Perm = self.Perm
4215 RW = Perm.R | Perm.W
4216 RX = Perm.R | Perm.X
4217 WX = Perm.W | Perm.X
4218 RWX = Perm.R | Perm.W | Perm.X
4219 values = list(Perm) + [RW, RX, WX, RWX, Perm(0)]
4220 for i in values:
4221 self.assertEqual(~i, (~i).value)
4222 self.assertIs(type(~i), Perm)
4223 self.assertEqual(~~i, i)
4224 for i in Perm:
4225 self.assertIs(~~i, i)
4226 Open = self.Open
4227 self.assertIs(Open.WO & ~Open.WO, Open.RO)
4228 self.assertIs((Open.WO|Open.CE) & ~Open.WO, Open.CE)
4229
4230 def test_boundary(self):
4231 self.assertIs(enum.IntFlag._boundary_, KEEP)
4232 class Simple(IntFlag, boundary=KEEP):
4233 SINGLE = 1
4234 #
4235 class Iron(IntFlag, boundary=STRICT):
4236 ONE = 1
4237 TWO = 2
4238 EIGHT = 8
4239 self.assertIs(Iron._boundary_, STRICT)
4240 #
4241 class Water(IntFlag, boundary=CONFORM):
4242 ONE = 1
4243 TWO = 2
4244 EIGHT = 8
4245 self.assertIs(Water._boundary_, CONFORM)
4246 #
4247 class Space(IntFlag, boundary=EJECT):
4248 ONE = 1
4249 TWO = 2
4250 EIGHT = 8
4251 self.assertIs(Space._boundary_, EJECT)
4252 #
4253 class Bizarre(IntFlag, boundary=KEEP):
4254 b = 3
4255 c = 4
4256 d = 6
4257 #
4258 self.assertRaisesRegex(ValueError, 'invalid value 5', Iron, 5)
4259 #
4260 self.assertIs(Water(7), Water.ONE|Water.TWO)
4261 self.assertIs(Water(~9), Water.TWO)
4262 #
4263 self.assertEqual(Space(7), 7)
4264 self.assertTrue(type(Space(7)) is int)
4265 #
4266 self.assertEqual(list(Bizarre), [Bizarre.c])
4267 self.assertIs(Bizarre(3), Bizarre.b)
4268 self.assertIs(Bizarre(6), Bizarre.d)
4269 #
4270 simple = Simple.SINGLE | Iron.TWO
4271 self.assertEqual(simple, 3)
4272 self.assertIsInstance(simple, Simple)
4273 self.assertEqual(repr(simple), '<Simple.SINGLE|<Iron.TWO: 2>: 3>')
4274 self.assertEqual(str(simple), '3')
4275
4276 def test_iter(self):
4277 Color = self.Color
4278 Open = self.Open
4279 self.assertEqual(list(Color), [Color.RED, Color.GREEN, Color.BLUE])
4280 self.assertEqual(list(Open), [Open.WO, Open.RW, Open.CE])
4281
4282 def test_programatic_function_string(self):
4283 Perm = IntFlag('Perm', 'R W X')
4284 lst = list(Perm)
4285 self.assertEqual(len(lst), len(Perm))
4286 self.assertEqual(len(Perm), 3, Perm)
4287 self.assertEqual(lst, [Perm.R, Perm.W, Perm.X])
4288 for i, n in enumerate('R W X'.split()):
4289 v = 1<<i
4290 e = Perm(v)
4291 self.assertEqual(e.value, v)
4292 self.assertEqual(type(e.value), int)
4293 self.assertEqual(e, v)
4294 self.assertEqual(e.name, n)
4295 self.assertIn(e, Perm)
4296 self.assertIs(type(e), Perm)
4297
4298 def test_programatic_function_string_with_start(self):
4299 Perm = IntFlag('Perm', 'R W X', start=8)
4300 lst = list(Perm)
4301 self.assertEqual(len(lst), len(Perm))
4302 self.assertEqual(len(Perm), 3, Perm)
4303 self.assertEqual(lst, [Perm.R, Perm.W, Perm.X])
4304 for i, n in enumerate('R W X'.split()):
4305 v = 8<<i
4306 e = Perm(v)
4307 self.assertEqual(e.value, v)
4308 self.assertEqual(type(e.value), int)
4309 self.assertEqual(e, v)
4310 self.assertEqual(e.name, n)
4311 self.assertIn(e, Perm)
4312 self.assertIs(type(e), Perm)
4313
4314 def test_programatic_function_string_list(self):
4315 Perm = IntFlag('Perm', ['R', 'W', 'X'])
4316 lst = list(Perm)
4317 self.assertEqual(len(lst), len(Perm))
4318 self.assertEqual(len(Perm), 3, Perm)
4319 self.assertEqual(lst, [Perm.R, Perm.W, Perm.X])
4320 for i, n in enumerate('R W X'.split()):
4321 v = 1<<i
4322 e = Perm(v)
4323 self.assertEqual(e.value, v)
4324 self.assertEqual(type(e.value), int)
4325 self.assertEqual(e, v)
4326 self.assertEqual(e.name, n)
4327 self.assertIn(e, Perm)
4328 self.assertIs(type(e), Perm)
4329
4330 def test_programatic_function_iterable(self):
4331 Perm = IntFlag('Perm', (('R', 2), ('W', 8), ('X', 32)))
4332 lst = list(Perm)
4333 self.assertEqual(len(lst), len(Perm))
4334 self.assertEqual(len(Perm), 3, Perm)
4335 self.assertEqual(lst, [Perm.R, Perm.W, Perm.X])
4336 for i, n in enumerate('R W X'.split()):
4337 v = 1<<(2*i+1)
4338 e = Perm(v)
4339 self.assertEqual(e.value, v)
4340 self.assertEqual(type(e.value), int)
4341 self.assertEqual(e, v)
4342 self.assertEqual(e.name, n)
4343 self.assertIn(e, Perm)
4344 self.assertIs(type(e), Perm)
4345
4346 def test_programatic_function_from_dict(self):
4347 Perm = IntFlag('Perm', OrderedDict((('R', 2), ('W', 8), ('X', 32))))
4348 lst = list(Perm)
4349 self.assertEqual(len(lst), len(Perm))
4350 self.assertEqual(len(Perm), 3, Perm)
4351 self.assertEqual(lst, [Perm.R, Perm.W, Perm.X])
4352 for i, n in enumerate('R W X'.split()):
4353 v = 1<<(2*i+1)
4354 e = Perm(v)
4355 self.assertEqual(e.value, v)
4356 self.assertEqual(type(e.value), int)
4357 self.assertEqual(e, v)
4358 self.assertEqual(e.name, n)
4359 self.assertIn(e, Perm)
4360 self.assertIs(type(e), Perm)
4361
4362
4363 def test_programatic_function_from_empty_list(self):
4364 Perm = enum.IntFlag('Perm', [])
4365 lst = list(Perm)
4366 self.assertEqual(len(lst), len(Perm))
4367 self.assertEqual(len(Perm), 0, Perm)
4368 Thing = enum.Enum('Thing', [])
4369 lst = list(Thing)
4370 self.assertEqual(len(lst), len(Thing))
4371 self.assertEqual(len(Thing), 0, Thing)
4372
4373
4374 def test_programatic_function_from_empty_tuple(self):
4375 Perm = enum.IntFlag('Perm', ())
4376 lst = list(Perm)
4377 self.assertEqual(len(lst), len(Perm))
4378 self.assertEqual(len(Perm), 0, Perm)
4379 Thing = enum.Enum('Thing', ())
4380 self.assertEqual(len(lst), len(Thing))
4381 self.assertEqual(len(Thing), 0, Thing)
4382
4383 def test_contains_tf(self):
4384 Open = self.Open
4385 Color = self.Color
4386 self.assertTrue(Color.GREEN in Color)
4387 self.assertTrue(Open.RW in Open)
4388 self.assertFalse('GREEN' in Color)
4389 self.assertFalse('RW' in Open)
4390 self.assertTrue(2 in Color)
4391 self.assertTrue(2 in Open)
4392
4393 def test_member_contains(self):
4394 Perm = self.Perm
4395 R, W, X = Perm
4396 RW = R | W
4397 RX = R | X
4398 WX = W | X
4399 RWX = R | W | X
4400 self.assertTrue(R in RW)
4401 self.assertTrue(R in RX)
4402 self.assertTrue(R in RWX)
4403 self.assertTrue(W in RW)
4404 self.assertTrue(W in WX)
4405 self.assertTrue(W in RWX)
4406 self.assertTrue(X in RX)
4407 self.assertTrue(X in WX)
4408 self.assertTrue(X in RWX)
4409 self.assertFalse(R in WX)
4410 self.assertFalse(W in RX)
4411 self.assertFalse(X in RW)
4412 with self.assertRaises(TypeError):
4413 self.assertFalse('test' in RW)
4414
4415 def test_member_iter(self):
4416 Color = self.Color
4417 self.assertEqual(list(Color.BLACK), [])
4418 self.assertEqual(list(Color.PURPLE), [Color.RED, Color.BLUE])
4419 self.assertEqual(list(Color.BLUE), [Color.BLUE])
4420 self.assertEqual(list(Color.GREEN), [Color.GREEN])
4421 self.assertEqual(list(Color.WHITE), [Color.RED, Color.GREEN, Color.BLUE])
4422
4423 def test_member_length(self):
4424 self.assertEqual(self.Color.__len__(self.Color.BLACK), 0)
4425 self.assertEqual(self.Color.__len__(self.Color.GREEN), 1)
4426 self.assertEqual(self.Color.__len__(self.Color.PURPLE), 2)
4427 self.assertEqual(self.Color.__len__(self.Color.BLANCO), 3)
4428
4429 def test_aliases(self):
4430 Color = self.Color
4431 self.assertEqual(Color(1).name, 'RED')
4432 self.assertEqual(Color['ROJO'].name, 'RED')
4433 self.assertEqual(Color(7).name, 'WHITE')
4434 self.assertEqual(Color['BLANCO'].name, 'WHITE')
4435 self.assertIs(Color.BLANCO, Color.WHITE)
4436 Open = self.Open
4437 self.assertIs(Open['AC'], Open.AC)
4438
4439 def test_bool(self):
4440 Perm = self.Perm
4441 for f in Perm:
4442 self.assertTrue(f)
4443 Open = self.Open
4444 for f in Open:
4445 self.assertEqual(bool(f.value), bool(f))
4446
4447
4448 def test_multiple_mixin(self):
4449 class AllMixin:
4450 @classproperty
4451 def ALL(cls):
4452 members = list(cls)
4453 all_value = None
4454 if members:
4455 all_value = members[0]
4456 for member in members[1:]:
4457 all_value |= member
4458 cls.ALL = all_value
4459 return all_value
4460 class StrMixin:
4461 def __str__(self):
4462 return self._name_.lower()
4463 class Color(AllMixin, IntFlag):
4464 RED = auto()
4465 GREEN = auto()
4466 BLUE = auto()
4467 self.assertEqual(Color.RED.value, 1)
4468 self.assertEqual(Color.GREEN.value, 2)
4469 self.assertEqual(Color.BLUE.value, 4)
4470 self.assertEqual(Color.ALL.value, 7)
4471 self.assertEqual(str(Color.BLUE), '4')
4472 class Color(AllMixin, StrMixin, IntFlag):
4473 RED = auto()
4474 GREEN = auto()
4475 BLUE = auto()
4476 __str__ = StrMixin.__str__
4477 self.assertEqual(Color.RED.value, 1)
4478 self.assertEqual(Color.GREEN.value, 2)
4479 self.assertEqual(Color.BLUE.value, 4)
4480 self.assertEqual(Color.ALL.value, 7)
4481 self.assertEqual(str(Color.BLUE), 'blue')
4482 class Color(StrMixin, AllMixin, IntFlag):
4483 RED = auto()
4484 GREEN = auto()
4485 BLUE = auto()
4486 __str__ = StrMixin.__str__
4487 self.assertEqual(Color.RED.value, 1)
4488 self.assertEqual(Color.GREEN.value, 2)
4489 self.assertEqual(Color.BLUE.value, 4)
4490 self.assertEqual(Color.ALL.value, 7)
4491 self.assertEqual(str(Color.BLUE), 'blue')
4492
4493 @threading_helper.reap_threads
4494 @threading_helper.requires_working_threading()
4495 def test_unique_composite(self):
4496 # override __eq__ to be identity only
4497 class TestFlag(IntFlag):
4498 one = auto()
4499 two = auto()
4500 three = auto()
4501 four = auto()
4502 five = auto()
4503 six = auto()
4504 seven = auto()
4505 eight = auto()
4506 def __eq__(self, other):
4507 return self is other
4508 def __hash__(self):
4509 return hash(self._value_)
4510 # have multiple threads competing to complete the composite members
4511 seen = set()
4512 failed = False
4513 def cycle_enum():
4514 nonlocal failed
4515 try:
4516 for i in range(256):
4517 seen.add(TestFlag(i))
4518 except Exception:
4519 failed = True
4520 threads = [
4521 threading.Thread(target=cycle_enum)
4522 for _ in range(8)
4523 ]
4524 with threading_helper.start_threads(threads):
4525 pass
4526 # check that only 248 members were created
4527 self.assertFalse(
4528 failed,
4529 'at least one thread failed while creating composite members')
4530 self.assertEqual(256, len(seen), 'too many composite members created')
4531
4532
4533 class TestEmptyAndNonLatinStrings(unittest.TestCase):
4534
4535 def test_empty_string(self):
4536 with self.assertRaises(ValueError):
4537 empty_abc = Enum('empty_abc', ('', 'B', 'C'))
4538
4539 def test_non_latin_character_string(self):
4540 greek_abc = Enum('greek_abc', ('\u03B1', 'B', 'C'))
4541 item = getattr(greek_abc, '\u03B1')
4542 self.assertEqual(item.value, 1)
4543
4544 def test_non_latin_number_string(self):
4545 hebrew_123 = Enum('hebrew_123', ('\u05D0', '2', '3'))
4546 item = getattr(hebrew_123, '\u05D0')
4547 self.assertEqual(item.value, 1)
4548
4549
4550 class TestUnique(unittest.TestCase):
4551
4552 def test_unique_clean(self):
4553 @unique
4554 class Clean(Enum):
4555 one = 1
4556 two = 'dos'
4557 tres = 4.0
4558 #
4559 @unique
4560 class Cleaner(IntEnum):
4561 single = 1
4562 double = 2
4563 triple = 3
4564
4565 def test_unique_dirty(self):
4566 with self.assertRaisesRegex(ValueError, 'tres.*one'):
4567 @unique
4568 class Dirty(Enum):
4569 one = 1
4570 two = 'dos'
4571 tres = 1
4572 with self.assertRaisesRegex(
4573 ValueError,
4574 'double.*single.*turkey.*triple',
4575 ):
4576 @unique
4577 class Dirtier(IntEnum):
4578 single = 1
4579 double = 1
4580 triple = 3
4581 turkey = 3
4582
4583 def test_unique_with_name(self):
4584 @verify(UNIQUE)
4585 class Silly(Enum):
4586 one = 1
4587 two = 'dos'
4588 name = 3
4589 #
4590 @verify(UNIQUE)
4591 class Sillier(IntEnum):
4592 single = 1
4593 name = 2
4594 triple = 3
4595 value = 4
4596
4597 class TestVerify(unittest.TestCase):
4598
4599 def test_continuous(self):
4600 @verify(CONTINUOUS)
4601 class Auto(Enum):
4602 FIRST = auto()
4603 SECOND = auto()
4604 THIRD = auto()
4605 FORTH = auto()
4606 #
4607 @verify(CONTINUOUS)
4608 class Manual(Enum):
4609 FIRST = 3
4610 SECOND = 4
4611 THIRD = 5
4612 FORTH = 6
4613 #
4614 with self.assertRaisesRegex(ValueError, 'invalid enum .Missing.: missing values 5, 6, 7, 8, 9, 10, 12'):
4615 @verify(CONTINUOUS)
4616 class Missing(Enum):
4617 FIRST = 3
4618 SECOND = 4
4619 THIRD = 11
4620 FORTH = 13
4621 #
4622 with self.assertRaisesRegex(ValueError, 'invalid flag .Incomplete.: missing values 32'):
4623 @verify(CONTINUOUS)
4624 class Incomplete(Flag):
4625 FIRST = 4
4626 SECOND = 8
4627 THIRD = 16
4628 FORTH = 64
4629 #
4630 with self.assertRaisesRegex(ValueError, 'invalid flag .StillIncomplete.: missing values 16'):
4631 @verify(CONTINUOUS)
4632 class StillIncomplete(Flag):
4633 FIRST = 4
4634 SECOND = 8
4635 THIRD = 11
4636 FORTH = 32
4637
4638
4639 def test_composite(self):
4640 class Bizarre(Flag):
4641 b = 3
4642 c = 4
4643 d = 6
4644 self.assertEqual(list(Bizarre), [Bizarre.c])
4645 self.assertEqual(Bizarre.b.value, 3)
4646 self.assertEqual(Bizarre.c.value, 4)
4647 self.assertEqual(Bizarre.d.value, 6)
4648 with self.assertRaisesRegex(
4649 ValueError,
4650 "invalid Flag 'Bizarre': aliases b and d are missing combined values of 0x3 .use enum.show_flag_values.value. for details.",
4651 ):
4652 @verify(NAMED_FLAGS)
4653 class Bizarre(Flag):
4654 b = 3
4655 c = 4
4656 d = 6
4657 #
4658 self.assertEqual(enum.show_flag_values(3), [1, 2])
4659 class Bizarre(IntFlag):
4660 b = 3
4661 c = 4
4662 d = 6
4663 self.assertEqual(list(Bizarre), [Bizarre.c])
4664 self.assertEqual(Bizarre.b.value, 3)
4665 self.assertEqual(Bizarre.c.value, 4)
4666 self.assertEqual(Bizarre.d.value, 6)
4667 with self.assertRaisesRegex(
4668 ValueError,
4669 "invalid Flag 'Bizarre': alias d is missing value 0x2 .use enum.show_flag_values.value. for details.",
4670 ):
4671 @verify(NAMED_FLAGS)
4672 class Bizarre(IntFlag):
4673 c = 4
4674 d = 6
4675 self.assertEqual(enum.show_flag_values(2), [2])
4676
4677 def test_unique_clean(self):
4678 @verify(UNIQUE)
4679 class Clean(Enum):
4680 one = 1
4681 two = 'dos'
4682 tres = 4.0
4683 #
4684 @verify(UNIQUE)
4685 class Cleaner(IntEnum):
4686 single = 1
4687 double = 2
4688 triple = 3
4689
4690 def test_unique_dirty(self):
4691 with self.assertRaisesRegex(ValueError, 'tres.*one'):
4692 @verify(UNIQUE)
4693 class Dirty(Enum):
4694 one = 1
4695 two = 'dos'
4696 tres = 1
4697 with self.assertRaisesRegex(
4698 ValueError,
4699 'double.*single.*turkey.*triple',
4700 ):
4701 @verify(UNIQUE)
4702 class Dirtier(IntEnum):
4703 single = 1
4704 double = 1
4705 triple = 3
4706 turkey = 3
4707
4708 def test_unique_with_name(self):
4709 @verify(UNIQUE)
4710 class Silly(Enum):
4711 one = 1
4712 two = 'dos'
4713 name = 3
4714 #
4715 @verify(UNIQUE)
4716 class Sillier(IntEnum):
4717 single = 1
4718 name = 2
4719 triple = 3
4720 value = 4
4721
4722 def test_negative_alias(self):
4723 @verify(NAMED_FLAGS)
4724 class Color(Flag):
4725 RED = 1
4726 GREEN = 2
4727 BLUE = 4
4728 WHITE = -1
4729 # no error means success
4730
4731
4732 class TestInternals(unittest.TestCase):
4733
4734 sunder_names = '_bad_', '_good_', '_what_ho_'
4735 dunder_names = '__mal__', '__bien__', '__que_que__'
4736 private_names = '_MyEnum__private', '_MyEnum__still_private'
4737 private_and_sunder_names = '_MyEnum__private_', '_MyEnum__also_private_'
4738 random_names = 'okay', '_semi_private', '_weird__', '_MyEnum__'
4739
4740 def test_sunder(self):
4741 for name in self.sunder_names + self.private_and_sunder_names:
4742 self.assertTrue(enum._is_sunder(name), '%r is a not sunder name?' % name)
4743 for name in self.dunder_names + self.private_names + self.random_names:
4744 self.assertFalse(enum._is_sunder(name), '%r is a sunder name?' % name)
4745
4746 def test_dunder(self):
4747 for name in self.dunder_names:
4748 self.assertTrue(enum._is_dunder(name), '%r is a not dunder name?' % name)
4749 for name in self.sunder_names + self.private_names + self.private_and_sunder_names + self.random_names:
4750 self.assertFalse(enum._is_dunder(name), '%r is a dunder name?' % name)
4751
4752 def test_is_private(self):
4753 for name in self.private_names + self.private_and_sunder_names:
4754 self.assertTrue(enum._is_private('MyEnum', name), '%r is a not private name?')
4755 for name in self.sunder_names + self.dunder_names + self.random_names:
4756 self.assertFalse(enum._is_private('MyEnum', name), '%r is a private name?')
4757
4758 def test_auto_number(self):
4759 class Color(Enum):
4760 red = auto()
4761 blue = auto()
4762 green = auto()
4763
4764 self.assertEqual(list(Color), [Color.red, Color.blue, Color.green])
4765 self.assertEqual(Color.red.value, 1)
4766 self.assertEqual(Color.blue.value, 2)
4767 self.assertEqual(Color.green.value, 3)
4768
4769 def test_auto_name(self):
4770 class Color(Enum):
4771 def _generate_next_value_(name, start, count, last):
4772 return name
4773 red = auto()
4774 blue = auto()
4775 green = auto()
4776
4777 self.assertEqual(list(Color), [Color.red, Color.blue, Color.green])
4778 self.assertEqual(Color.red.value, 'red')
4779 self.assertEqual(Color.blue.value, 'blue')
4780 self.assertEqual(Color.green.value, 'green')
4781
4782 def test_auto_name_inherit(self):
4783 class AutoNameEnum(Enum):
4784 def _generate_next_value_(name, start, count, last):
4785 return name
4786 class Color(AutoNameEnum):
4787 red = auto()
4788 blue = auto()
4789 green = auto()
4790
4791 self.assertEqual(list(Color), [Color.red, Color.blue, Color.green])
4792 self.assertEqual(Color.red.value, 'red')
4793 self.assertEqual(Color.blue.value, 'blue')
4794 self.assertEqual(Color.green.value, 'green')
4795
4796 @unittest.skipIf(
4797 python_version >= (3, 13),
4798 'mixed types with auto() no longer supported',
4799 )
4800 def test_auto_garbage_ok(self):
4801 with self.assertWarnsRegex(DeprecationWarning, 'will require all values to be sortable'):
4802 class Color(Enum):
4803 red = 'red'
4804 blue = auto()
4805 self.assertEqual(Color.blue.value, 1)
4806
4807 @unittest.skipIf(
4808 python_version >= (3, 13),
4809 'mixed types with auto() no longer supported',
4810 )
4811 def test_auto_garbage_corrected_ok(self):
4812 with self.assertWarnsRegex(DeprecationWarning, 'will require all values to be sortable'):
4813 class Color(Enum):
4814 red = 'red'
4815 blue = 2
4816 green = auto()
4817
4818 self.assertEqual(list(Color), [Color.red, Color.blue, Color.green])
4819 self.assertEqual(Color.red.value, 'red')
4820 self.assertEqual(Color.blue.value, 2)
4821 self.assertEqual(Color.green.value, 3)
4822
4823 @unittest.skipIf(
4824 python_version < (3, 13),
4825 'mixed types with auto() will raise in 3.13',
4826 )
4827 def test_auto_garbage_fail(self):
4828 with self.assertRaisesRegex(TypeError, "unable to increment 'red'"):
4829 class Color(Enum):
4830 red = 'red'
4831 blue = auto()
4832
4833 @unittest.skipIf(
4834 python_version < (3, 13),
4835 'mixed types with auto() will raise in 3.13',
4836 )
4837 def test_auto_garbage_corrected_fail(self):
4838 with self.assertRaisesRegex(TypeError, 'unable to sort non-numeric values'):
4839 class Color(Enum):
4840 red = 'red'
4841 blue = 2
4842 green = auto()
4843
4844 def test_auto_order(self):
4845 with self.assertRaises(TypeError):
4846 class Color(Enum):
4847 red = auto()
4848 green = auto()
4849 blue = auto()
4850 def _generate_next_value_(name, start, count, last):
4851 return name
4852
4853 def test_auto_order_wierd(self):
4854 weird_auto = auto()
4855 weird_auto.value = 'pathological case'
4856 class Color(Enum):
4857 red = weird_auto
4858 def _generate_next_value_(name, start, count, last):
4859 return name
4860 blue = auto()
4861 self.assertEqual(list(Color), [Color.red, Color.blue])
4862 self.assertEqual(Color.red.value, 'pathological case')
4863 self.assertEqual(Color.blue.value, 'blue')
4864
4865 @unittest.skipIf(
4866 python_version < (3, 13),
4867 'auto() will return highest value + 1 in 3.13',
4868 )
4869 def test_auto_with_aliases(self):
4870 class Color(Enum):
4871 red = auto()
4872 blue = auto()
4873 oxford = blue
4874 crimson = red
4875 green = auto()
4876 self.assertIs(Color.crimson, Color.red)
4877 self.assertIs(Color.oxford, Color.blue)
4878 self.assertIsNot(Color.green, Color.red)
4879 self.assertIsNot(Color.green, Color.blue)
4880
4881 def test_duplicate_auto(self):
4882 class Dupes(Enum):
4883 first = primero = auto()
4884 second = auto()
4885 third = auto()
4886 self.assertEqual([Dupes.first, Dupes.second, Dupes.third], list(Dupes))
4887
4888 def test_multiple_auto_on_line(self):
4889 class Huh(Enum):
4890 ONE = auto()
4891 TWO = auto(), auto()
4892 THREE = auto(), auto(), auto()
4893 self.assertEqual(Huh.ONE.value, 1)
4894 self.assertEqual(Huh.TWO.value, (2, 3))
4895 self.assertEqual(Huh.THREE.value, (4, 5, 6))
4896 #
4897 class Hah(Enum):
4898 def __new__(cls, value, abbr=None):
4899 member = object.__new__(cls)
4900 member._value_ = value
4901 member.abbr = abbr or value[:3].lower()
4902 return member
4903 def _generate_next_value_(name, start, count, last):
4904 return name
4905 #
4906 MONDAY = auto()
4907 TUESDAY = auto()
4908 WEDNESDAY = auto(), 'WED'
4909 THURSDAY = auto(), 'Thu'
4910 FRIDAY = auto()
4911 self.assertEqual(Hah.MONDAY.value, 'MONDAY')
4912 self.assertEqual(Hah.MONDAY.abbr, 'mon')
4913 self.assertEqual(Hah.TUESDAY.value, 'TUESDAY')
4914 self.assertEqual(Hah.TUESDAY.abbr, 'tue')
4915 self.assertEqual(Hah.WEDNESDAY.value, 'WEDNESDAY')
4916 self.assertEqual(Hah.WEDNESDAY.abbr, 'WED')
4917 self.assertEqual(Hah.THURSDAY.value, 'THURSDAY')
4918 self.assertEqual(Hah.THURSDAY.abbr, 'Thu')
4919 self.assertEqual(Hah.FRIDAY.value, 'FRIDAY')
4920 self.assertEqual(Hah.FRIDAY.abbr, 'fri')
4921 #
4922 class Huh(Enum):
4923 def _generate_next_value_(name, start, count, last):
4924 return count+1
4925 ONE = auto()
4926 TWO = auto(), auto()
4927 THREE = auto(), auto(), auto()
4928 self.assertEqual(Huh.ONE.value, 1)
4929 self.assertEqual(Huh.TWO.value, (2, 2))
4930 self.assertEqual(Huh.THREE.value, (3, 3, 3))
4931
4932
4933 expected_help_output_with_docs = """\
4934 Help on class Color in module %s:
4935
4936 class Color(enum.Enum)
4937 | Color(*values)
4938 |
4939 | Method resolution order:
4940 | Color
4941 | enum.Enum
4942 | builtins.object
4943 |
4944 | Data and other attributes defined here:
4945 |
4946 | CYAN = <Color.CYAN: 1>
4947 |
4948 | MAGENTA = <Color.MAGENTA: 2>
4949 |
4950 | YELLOW = <Color.YELLOW: 3>
4951 |
4952 | ----------------------------------------------------------------------
4953 | Data descriptors inherited from enum.Enum:
4954 |
4955 | name
4956 | The name of the Enum member.
4957 |
4958 | value
4959 | The value of the Enum member.
4960 |
4961 | ----------------------------------------------------------------------
4962 | Static methods inherited from enum.EnumType:
4963 |
4964 | __contains__(value)
4965 | Return True if `value` is in `cls`.
4966 |
4967 | `value` is in `cls` if:
4968 | 1) `value` is a member of `cls`, or
4969 | 2) `value` is the value of one of the `cls`'s members.
4970 | 3) `value` is a pseudo-member (flags)
4971 |
4972 | __getitem__(name)
4973 | Return the member matching `name`.
4974 |
4975 | __iter__()
4976 | Return members in definition order.
4977 |
4978 | __len__()
4979 | Return the number of members (no aliases)
4980 |
4981 | ----------------------------------------------------------------------
4982 | Readonly properties inherited from enum.EnumType:
4983 |
4984 | __members__
4985 | Returns a mapping of member name->value.
4986 |
4987 | This mapping lists all enum members, including aliases. Note that this
4988 | is a read-only view of the internal mapping."""
4989
4990 expected_help_output_without_docs = """\
4991 Help on class Color in module %s:
4992
4993 class Color(enum.Enum)
4994 | Color(*values)
4995 |
4996 | Method resolution order:
4997 | Color
4998 | enum.Enum
4999 | builtins.object
5000 |
5001 | Data and other attributes defined here:
5002 |
5003 | CYAN = <Color.CYAN: 1>
5004 |
5005 | MAGENTA = <Color.MAGENTA: 2>
5006 |
5007 | YELLOW = <Color.YELLOW: 3>
5008 |
5009 | ----------------------------------------------------------------------
5010 | Data descriptors inherited from enum.Enum:
5011 |
5012 | name
5013 |
5014 | value
5015 |
5016 | ----------------------------------------------------------------------
5017 | Static methods inherited from enum.EnumType:
5018 |
5019 | __contains__(value)
5020 |
5021 | __getitem__(name)
5022 |
5023 | __iter__()
5024 |
5025 | __len__()
5026 |
5027 | ----------------------------------------------------------------------
5028 | Readonly properties inherited from enum.EnumType:
5029 |
5030 | __members__"""
5031
5032 class TestStdLib(unittest.TestCase):
5033
5034 maxDiff = None
5035
5036 class Color(Enum):
5037 CYAN = 1
5038 MAGENTA = 2
5039 YELLOW = 3
5040
5041 def test_pydoc(self):
5042 # indirectly test __objclass__
5043 if StrEnum.__doc__ is None:
5044 expected_text = expected_help_output_without_docs % __name__
5045 else:
5046 expected_text = expected_help_output_with_docs % __name__
5047 output = StringIO()
5048 helper = pydoc.Helper(output=output)
5049 helper(self.Color)
5050 result = output.getvalue().strip()
5051 self.assertEqual(result, expected_text, result)
5052
5053 def test_inspect_getmembers(self):
5054 values = dict((
5055 ('__class__', EnumType),
5056 ('__doc__', '...'),
5057 ('__members__', self.Color.__members__),
5058 ('__module__', __name__),
5059 ('YELLOW', self.Color.YELLOW),
5060 ('MAGENTA', self.Color.MAGENTA),
5061 ('CYAN', self.Color.CYAN),
5062 ('name', Enum.__dict__['name']),
5063 ('value', Enum.__dict__['value']),
5064 ('__len__', self.Color.__len__),
5065 ('__contains__', self.Color.__contains__),
5066 ('__name__', 'Color'),
5067 ('__getitem__', self.Color.__getitem__),
5068 ('__qualname__', 'TestStdLib.Color'),
5069 ('__init_subclass__', getattr(self.Color, '__init_subclass__')),
5070 ('__iter__', self.Color.__iter__),
5071 ))
5072 result = dict(inspect.getmembers(self.Color))
5073 self.assertEqual(set(values.keys()), set(result.keys()))
5074 failed = False
5075 for k in values.keys():
5076 if k == '__doc__':
5077 # __doc__ is huge, not comparing
5078 continue
5079 if result[k] != values[k]:
5080 print()
5081 print('\n%s\n key: %s\n result: %s\nexpected: %s\n%s\n' %
5082 ('=' * 75, k, result[k], values[k], '=' * 75), sep='')
5083 failed = True
5084 if failed:
5085 self.fail("result does not equal expected, see print above")
5086
5087 def test_inspect_classify_class_attrs(self):
5088 # indirectly test __objclass__
5089 from inspect import Attribute
5090 values = [
5091 Attribute(name='__class__', kind='data',
5092 defining_class=object, object=EnumType),
5093 Attribute(name='__contains__', kind='method',
5094 defining_class=EnumType, object=self.Color.__contains__),
5095 Attribute(name='__doc__', kind='data',
5096 defining_class=self.Color, object='...'),
5097 Attribute(name='__getitem__', kind='method',
5098 defining_class=EnumType, object=self.Color.__getitem__),
5099 Attribute(name='__iter__', kind='method',
5100 defining_class=EnumType, object=self.Color.__iter__),
5101 Attribute(name='__init_subclass__', kind='class method',
5102 defining_class=object, object=getattr(self.Color, '__init_subclass__')),
5103 Attribute(name='__len__', kind='method',
5104 defining_class=EnumType, object=self.Color.__len__),
5105 Attribute(name='__members__', kind='property',
5106 defining_class=EnumType, object=EnumType.__members__),
5107 Attribute(name='__module__', kind='data',
5108 defining_class=self.Color, object=__name__),
5109 Attribute(name='__name__', kind='data',
5110 defining_class=self.Color, object='Color'),
5111 Attribute(name='__qualname__', kind='data',
5112 defining_class=self.Color, object='TestStdLib.Color'),
5113 Attribute(name='YELLOW', kind='data',
5114 defining_class=self.Color, object=self.Color.YELLOW),
5115 Attribute(name='MAGENTA', kind='data',
5116 defining_class=self.Color, object=self.Color.MAGENTA),
5117 Attribute(name='CYAN', kind='data',
5118 defining_class=self.Color, object=self.Color.CYAN),
5119 Attribute(name='name', kind='data',
5120 defining_class=Enum, object=Enum.__dict__['name']),
5121 Attribute(name='value', kind='data',
5122 defining_class=Enum, object=Enum.__dict__['value']),
5123 ]
5124 for v in values:
5125 try:
5126 v.name
5127 except AttributeError:
5128 print(v)
5129 values.sort(key=lambda item: item.name)
5130 result = list(inspect.classify_class_attrs(self.Color))
5131 result.sort(key=lambda item: item.name)
5132 self.assertEqual(
5133 len(values), len(result),
5134 "%s != %s" % ([a.name for a in values], [a.name for a in result])
5135 )
5136 failed = False
5137 for v, r in zip(values, result):
5138 if r.name in ('__init_subclass__', '__doc__'):
5139 # not sure how to make the __init_subclass_ Attributes match
5140 # so as long as there is one, call it good
5141 # __doc__ is too big to check exactly, so treat the same as __init_subclass__
5142 for name in ('name','kind','defining_class'):
5143 if getattr(v, name) != getattr(r, name):
5144 print('\n%s\n%s\n%s\n%s\n' % ('=' * 75, r, v, '=' * 75), sep='')
5145 failed = True
5146 elif r != v:
5147 print('\n%s\n%s\n%s\n%s\n' % ('=' * 75, r, v, '=' * 75), sep='')
5148 failed = True
5149 if failed:
5150 self.fail("result does not equal expected, see print above")
5151
5152 def test_inspect_signatures(self):
5153 from inspect import signature, Signature, Parameter
5154 self.assertEqual(
5155 signature(Enum),
5156 Signature([
5157 Parameter('new_class_name', Parameter.POSITIONAL_ONLY),
5158 Parameter('names', Parameter.POSITIONAL_OR_KEYWORD),
5159 Parameter('module', Parameter.KEYWORD_ONLY, default=None),
5160 Parameter('qualname', Parameter.KEYWORD_ONLY, default=None),
5161 Parameter('type', Parameter.KEYWORD_ONLY, default=None),
5162 Parameter('start', Parameter.KEYWORD_ONLY, default=1),
5163 Parameter('boundary', Parameter.KEYWORD_ONLY, default=None),
5164 ]),
5165 )
5166 self.assertEqual(
5167 signature(enum.FlagBoundary),
5168 Signature([
5169 Parameter('values', Parameter.VAR_POSITIONAL),
5170 ]),
5171 )
5172
5173 def test_test_simple_enum(self):
5174 @_simple_enum(Enum)
5175 class SimpleColor:
5176 CYAN = 1
5177 MAGENTA = 2
5178 YELLOW = 3
5179 @bltns.property
5180 def zeroth(self):
5181 return 'zeroed %s' % self.name
5182 class CheckedColor(Enum):
5183 CYAN = 1
5184 MAGENTA = 2
5185 YELLOW = 3
5186 @bltns.property
5187 def zeroth(self):
5188 return 'zeroed %s' % self.name
5189 _test_simple_enum(CheckedColor, SimpleColor)
5190 SimpleColor.MAGENTA._value_ = 9
5191 self.assertRaisesRegex(
5192 TypeError, "enum mismatch",
5193 _test_simple_enum, CheckedColor, SimpleColor,
5194 )
5195 #
5196 #
5197 class CheckedMissing(IntFlag, boundary=KEEP):
5198 SIXTY_FOUR = 64
5199 ONE_TWENTY_EIGHT = 128
5200 TWENTY_FORTY_EIGHT = 2048
5201 ALL = 2048 + 128 + 64 + 12
5202 CM = CheckedMissing
5203 self.assertEqual(list(CheckedMissing), [CM.SIXTY_FOUR, CM.ONE_TWENTY_EIGHT, CM.TWENTY_FORTY_EIGHT])
5204 #
5205 @_simple_enum(IntFlag, boundary=KEEP)
5206 class Missing:
5207 SIXTY_FOUR = 64
5208 ONE_TWENTY_EIGHT = 128
5209 TWENTY_FORTY_EIGHT = 2048
5210 ALL = 2048 + 128 + 64 + 12
5211 M = Missing
5212 self.assertEqual(list(CheckedMissing), [M.SIXTY_FOUR, M.ONE_TWENTY_EIGHT, M.TWENTY_FORTY_EIGHT])
5213 _test_simple_enum(CheckedMissing, Missing)
5214 #
5215 #
5216 class CheckedUnhashable(Enum):
5217 ONE = dict()
5218 TWO = set()
5219 name = 'python'
5220 self.assertIn(dict(), CheckedUnhashable)
5221 self.assertIn('python', CheckedUnhashable)
5222 self.assertEqual(CheckedUnhashable.name.value, 'python')
5223 self.assertEqual(CheckedUnhashable.name.name, 'name')
5224 #
5225 @_simple_enum()
5226 class Unhashable:
5227 ONE = dict()
5228 TWO = set()
5229 name = 'python'
5230 self.assertIn(dict(), Unhashable)
5231 self.assertIn('python', Unhashable)
5232 self.assertEqual(Unhashable.name.value, 'python')
5233 self.assertEqual(Unhashable.name.name, 'name')
5234 _test_simple_enum(CheckedUnhashable, Unhashable)
5235 ##
5236 class CheckedComplexStatus(IntEnum):
5237 def __new__(cls, value, phrase, description=''):
5238 obj = int.__new__(cls, value)
5239 obj._value_ = value
5240 obj.phrase = phrase
5241 obj.description = description
5242 return obj
5243 CONTINUE = 100, 'Continue', 'Request received, please continue'
5244 PROCESSING = 102, 'Processing'
5245 EARLY_HINTS = 103, 'Early Hints'
5246 SOME_HINTS = 103, 'Some Early Hints'
5247 #
5248 @_simple_enum(IntEnum)
5249 class ComplexStatus:
5250 def __new__(cls, value, phrase, description=''):
5251 obj = int.__new__(cls, value)
5252 obj._value_ = value
5253 obj.phrase = phrase
5254 obj.description = description
5255 return obj
5256 CONTINUE = 100, 'Continue', 'Request received, please continue'
5257 PROCESSING = 102, 'Processing'
5258 EARLY_HINTS = 103, 'Early Hints'
5259 SOME_HINTS = 103, 'Some Early Hints'
5260 _test_simple_enum(CheckedComplexStatus, ComplexStatus)
5261 #
5262 #
5263 class CheckedComplexFlag(IntFlag):
5264 def __new__(cls, value, label):
5265 obj = int.__new__(cls, value)
5266 obj._value_ = value
5267 obj.label = label
5268 return obj
5269 SHIRT = 1, 'upper half'
5270 VEST = 1, 'outer upper half'
5271 PANTS = 2, 'lower half'
5272 self.assertIs(CheckedComplexFlag.SHIRT, CheckedComplexFlag.VEST)
5273 #
5274 @_simple_enum(IntFlag)
5275 class ComplexFlag:
5276 def __new__(cls, value, label):
5277 obj = int.__new__(cls, value)
5278 obj._value_ = value
5279 obj.label = label
5280 return obj
5281 SHIRT = 1, 'upper half'
5282 VEST = 1, 'uppert half'
5283 PANTS = 2, 'lower half'
5284 _test_simple_enum(CheckedComplexFlag, ComplexFlag)
5285
5286
5287 class MiscTestCase(unittest.TestCase):
5288
5289 def test__all__(self):
5290 support.check__all__(self, enum, not_exported={'bin', 'show_flag_values'})
5291
5292 @cpython_only
5293 def test_lazy_import(self):
5294 ensure_lazy_imports("enum", {"functools", "warnings", "inspect", "re"})
5295
5296 def test_doc_1(self):
5297 class Single(Enum):
5298 ONE = 1
5299 self.assertEqual(Single.__doc__, None)
5300
5301 def test_doc_2(self):
5302 class Double(Enum):
5303 ONE = 1
5304 TWO = 2
5305 self.assertEqual(Double.__doc__, None)
5306
5307 def test_doc_3(self):
5308 class Triple(Enum):
5309 ONE = 1
5310 TWO = 2
5311 THREE = 3
5312 self.assertEqual(Triple.__doc__, None)
5313
5314 def test_doc_4(self):
5315 class Quadruple(Enum):
5316 ONE = 1
5317 TWO = 2
5318 THREE = 3
5319 FOUR = 4
5320 self.assertEqual(Quadruple.__doc__, None)
5321
5322
5323 # These are unordered here on purpose to ensure that declaration order
5324 # makes no difference.
5325 CONVERT_TEST_NAME_D = 5
5326 CONVERT_TEST_NAME_C = 5
5327 CONVERT_TEST_NAME_B = 5
5328 CONVERT_TEST_NAME_A = 5 # This one should sort first.
5329 CONVERT_TEST_NAME_E = 5
5330 CONVERT_TEST_NAME_F = 5
5331
5332 CONVERT_STRING_TEST_NAME_D = 5
5333 CONVERT_STRING_TEST_NAME_C = 5
5334 CONVERT_STRING_TEST_NAME_B = 5
5335 CONVERT_STRING_TEST_NAME_A = 5 # This one should sort first.
5336 CONVERT_STRING_TEST_NAME_E = 5
5337 CONVERT_STRING_TEST_NAME_F = 5
5338
5339 # global names for StrEnum._convert_ test
5340 CONVERT_STR_TEST_2 = 'goodbye'
5341 CONVERT_STR_TEST_1 = 'hello'
5342
5343 # We also need values that cannot be compared:
5344 UNCOMPARABLE_A = 5
5345 UNCOMPARABLE_C = (9, 1) # naming order is broken on purpose
5346 UNCOMPARABLE_B = 'value'
5347
5348 COMPLEX_C = 1j
5349 COMPLEX_A = 2j
5350 COMPLEX_B = 3j
5351
5352 class TestConvert(unittest.TestCase):
5353 def tearDown(self):
5354 # Reset the module-level test variables to their original integer
5355 # values, otherwise the already created enum values get converted
5356 # instead.
5357 g = globals()
5358 for suffix in ['A', 'B', 'C', 'D', 'E', 'F']:
5359 g['CONVERT_TEST_NAME_%s' % suffix] = 5
5360 g['CONVERT_STRING_TEST_NAME_%s' % suffix] = 5
5361 for suffix, value in (('A', 5), ('B', (9, 1)), ('C', 'value')):
5362 g['UNCOMPARABLE_%s' % suffix] = value
5363 for suffix, value in (('A', 2j), ('B', 3j), ('C', 1j)):
5364 g['COMPLEX_%s' % suffix] = value
5365 for suffix, value in (('1', 'hello'), ('2', 'goodbye')):
5366 g['CONVERT_STR_TEST_%s' % suffix] = value
5367
5368 def test_convert_value_lookup_priority(self):
5369 test_type = enum.IntEnum._convert_(
5370 'UnittestConvert',
5371 MODULE,
5372 filter=lambda x: x.startswith('CONVERT_TEST_'))
5373 # We don't want the reverse lookup value to vary when there are
5374 # multiple possible names for a given value. It should always
5375 # report the first lexicographical name in that case.
5376 self.assertEqual(test_type(5).name, 'CONVERT_TEST_NAME_A')
5377
5378 def test_convert_int(self):
5379 test_type = enum.IntEnum._convert_(
5380 'UnittestConvert',
5381 MODULE,
5382 filter=lambda x: x.startswith('CONVERT_TEST_'))
5383 # Ensure that test_type has all of the desired names and values.
5384 self.assertEqual(test_type.CONVERT_TEST_NAME_F,
5385 test_type.CONVERT_TEST_NAME_A)
5386 self.assertEqual(test_type.CONVERT_TEST_NAME_B, 5)
5387 self.assertEqual(test_type.CONVERT_TEST_NAME_C, 5)
5388 self.assertEqual(test_type.CONVERT_TEST_NAME_D, 5)
5389 self.assertEqual(test_type.CONVERT_TEST_NAME_E, 5)
5390 # Ensure that test_type only picked up names matching the filter.
5391 extra = [name for name in dir(test_type) if name not in enum_dir(test_type)]
5392 missing = [name for name in enum_dir(test_type) if name not in dir(test_type)]
5393 self.assertEqual(
5394 extra + missing,
5395 [],
5396 msg='extra names: %r; missing names: %r' % (extra, missing),
5397 )
5398
5399
5400 def test_convert_uncomparable(self):
5401 uncomp = enum.Enum._convert_(
5402 'Uncomparable',
5403 MODULE,
5404 filter=lambda x: x.startswith('UNCOMPARABLE_'))
5405 # Should be ordered by `name` only:
5406 self.assertEqual(
5407 list(uncomp),
5408 [uncomp.UNCOMPARABLE_A, uncomp.UNCOMPARABLE_B, uncomp.UNCOMPARABLE_C],
5409 )
5410
5411 def test_convert_complex(self):
5412 uncomp = enum.Enum._convert_(
5413 'Uncomparable',
5414 MODULE,
5415 filter=lambda x: x.startswith('COMPLEX_'))
5416 # Should be ordered by `name` only:
5417 self.assertEqual(
5418 list(uncomp),
5419 [uncomp.COMPLEX_A, uncomp.COMPLEX_B, uncomp.COMPLEX_C],
5420 )
5421
5422 def test_convert_str(self):
5423 test_type = enum.StrEnum._convert_(
5424 'UnittestConvert',
5425 MODULE,
5426 filter=lambda x: x.startswith('CONVERT_STR_'),
5427 as_global=True)
5428 # Ensure that test_type has all of the desired names and values.
5429 self.assertEqual(test_type.CONVERT_STR_TEST_1, 'hello')
5430 self.assertEqual(test_type.CONVERT_STR_TEST_2, 'goodbye')
5431 # Ensure that test_type only picked up names matching the filter.
5432 extra = [name for name in dir(test_type) if name not in enum_dir(test_type)]
5433 missing = [name for name in enum_dir(test_type) if name not in dir(test_type)]
5434 self.assertEqual(
5435 extra + missing,
5436 [],
5437 msg='extra names: %r; missing names: %r' % (extra, missing),
5438 )
5439 self.assertEqual(repr(test_type.CONVERT_STR_TEST_1), '%s.CONVERT_STR_TEST_1' % SHORT_MODULE)
5440 self.assertEqual(str(test_type.CONVERT_STR_TEST_2), 'goodbye')
5441 self.assertEqual(format(test_type.CONVERT_STR_TEST_1), 'hello')
5442
5443 def test_convert_raise(self):
5444 with self.assertRaises(AttributeError):
5445 enum.IntEnum._convert(
5446 'UnittestConvert',
5447 MODULE,
5448 filter=lambda x: x.startswith('CONVERT_TEST_'))
5449
5450 def test_convert_repr_and_str(self):
5451 test_type = enum.IntEnum._convert_(
5452 'UnittestConvert',
5453 MODULE,
5454 filter=lambda x: x.startswith('CONVERT_STRING_TEST_'),
5455 as_global=True)
5456 self.assertEqual(repr(test_type.CONVERT_STRING_TEST_NAME_A), '%s.CONVERT_STRING_TEST_NAME_A' % SHORT_MODULE)
5457 self.assertEqual(str(test_type.CONVERT_STRING_TEST_NAME_A), '5')
5458 self.assertEqual(format(test_type.CONVERT_STRING_TEST_NAME_A), '5')
5459
5460
5461 class TestEnumDict(unittest.TestCase):
5462 def test_enum_dict_in_metaclass(self):
5463 """Test that EnumDict is usable as a class namespace"""
5464 class Meta(type):
5465 @classmethod
5466 def __prepare__(metacls, cls, bases, **kwds):
5467 return EnumDict(cls)
5468
5469 class MyClass(metaclass=Meta):
5470 a = 1
5471
5472 with self.assertRaises(TypeError):
5473 a = 2 # duplicate
5474
5475 with self.assertRaises(ValueError):
5476 _a_sunder_ = 3
5477
5478 def test_enum_dict_standalone(self):
5479 """Test that EnumDict is usable on its own"""
5480 enumdict = EnumDict()
5481 enumdict['a'] = 1
5482
5483 with self.assertRaises(TypeError):
5484 enumdict['a'] = 'other value'
5485
5486 # Only MutableMapping interface is overridden for now.
5487 # If this stops passing, update the documentation.
5488 enumdict |= {'a': 'other value'}
5489 self.assertEqual(enumdict['a'], 'other value')
5490
5491
5492 # helpers
5493
5494 def enum_dir(cls):
5495 interesting = set([
5496 '__class__', '__contains__', '__doc__', '__getitem__',
5497 '__iter__', '__len__', '__members__', '__module__',
5498 '__name__', '__qualname__',
5499 ]
5500 + cls._member_names_
5501 )
5502 if cls._new_member_ is not object.__new__:
5503 interesting.add('__new__')
5504 if cls.__init_subclass__ is not object.__init_subclass__:
5505 interesting.add('__init_subclass__')
5506 if cls._member_type_ is object:
5507 return sorted(interesting)
5508 else:
5509 # return whatever mixed-in data type has
5510 return sorted(set(dir(cls._member_type_)) | interesting)
5511
5512 def member_dir(member):
5513 if member.__class__._member_type_ is object:
5514 allowed = set(['__class__', '__doc__', '__eq__', '__hash__', '__module__', 'name', 'value'])
5515 else:
5516 allowed = set(dir(member))
5517 for cls in member.__class__.mro():
5518 for name, obj in cls.__dict__.items():
5519 if name[0] == '_':
5520 continue
5521 if isinstance(obj, enum.property):
5522 if obj.fget is not None or name not in member._member_map_:
5523 allowed.add(name)
5524 else:
5525 allowed.discard(name)
5526 elif name not in member._member_map_:
5527 allowed.add(name)
5528 return sorted(allowed)
5529
5530
5531 if __name__ == '__main__':
5532 unittest.main()