diff options
Diffstat (limited to 'venv/Lib/site-packages/aenum/test.py')
| -rw-r--r-- | venv/Lib/site-packages/aenum/test.py | 6832 |
1 files changed, 0 insertions, 6832 deletions
diff --git a/venv/Lib/site-packages/aenum/test.py b/venv/Lib/site-packages/aenum/test.py deleted file mode 100644 index 224293cb..00000000 --- a/venv/Lib/site-packages/aenum/test.py +++ /dev/null @@ -1,6832 +0,0 @@ -# -*- coding: utf-8 -*- - -from __future__ import division, print_function -import sys -import aenum -import doctest -import os -import shutil -import tempfile -import textwrap -import unittest -import uuid -import warnings -from aenum import EnumType, EnumMeta, Enum, IntEnum, StrEnum, LowerStrEnum, UpperStrEnum -from aenum import AutoNumberEnum, MultiValueEnum, OrderedEnum, UniqueEnum, AddValueEnum, Flag, IntFlag -from aenum import NamedTuple, TupleSize, NamedConstant, constant, NoAlias, AddValue, Unique -from aenum import STRICT, CONFORM, EJECT, KEEP -from aenum import _reduce_ex_by_name, unique, skip, extend_enum, auto, enum, MultiValue, member, nonmember, no_arg -from aenum import basestring, baseinteger, unicode, enum_property -from aenum import pyver, PY2, PY3, PY2_6, PY3_3, PY3_4, PY3_5, PY3_6, PY3_11 -from collections import OrderedDict -from datetime import timedelta -from pickle import dumps, loads, PicklingError, HIGHEST_PROTOCOL -from operator import or_ as _or_, and_ as _and_, xor as _xor_, inv as _inv_ -from operator import abs as _abs_, add as _add_, floordiv as _floordiv_ -from operator import lshift as _lshift_, rshift as _rshift_, mod as _mod_ -from operator import mul as _mul_, neg as _neg_, pos as _pos_, pow as _pow_ -from operator import truediv as _truediv_, sub as _sub_ -if PY2: - from operator import div as _div_ -try: - import threading -except ImportError: - threading = None - -try: - any -except NameError: - from aenum import any - -MODULE = __name__ -SHORT_MODULE = MODULE.split('.')[-1] - -def load_tests(loader, tests, ignore): - tests.addTests(doctest.DocTestSuite(aenum)) - tests.addTests(doctest.DocFileSuite( - 'doc/aenum.rst', - package=aenum, - optionflags=doctest.ELLIPSIS|doctest.NORMALIZE_WHITESPACE, - )) - return tests - -class TestCase(unittest.TestCase): - - def __init__(self, *args, **kwds): - regex = getattr(self, 'assertRaisesRegex', None) - if regex is None: - self.assertRaisesRegex = getattr(self, 'assertRaisesRegexp') - super(TestCase, self).__init__(*args, **kwds) - - -# for pickle tests -try: - class Stooges(Enum): - LARRY = 1 - CURLY = 2 - MOE = 3 -except Exception: - Stooges = sys.exc_info()[1] - -try: - class IntStooges(int, Enum): - LARRY = 1 - CURLY = 2 - MOE = 3 -except Exception: - IntStooges = sys.exc_info()[1] - -try: - class FloatStooges(float, Enum): - LARRY = 1.39 - CURLY = 2.72 - MOE = 3.142596 -except Exception: - FloatStooges = sys.exc_info()[1] - -try: - class FlagStooges(Flag): - LARRY = 1 - CURLY = 2 - MOE = 3 -except Exception as exc: - FlagStooges = exc - -try: - LifeForm = NamedTuple('LifeForm', 'branch genus species', module=__name__) -except Exception: - LifeForm = sys.exc_info()[1] - -try: - class DeathForm(NamedTuple): - color = 0 - rigidity = 1 - odor = 2 -except Exception: - DeathForm = sys.exc_info()[1] - -# for pickle test and subclass tests -try: - class Name(StrEnum): - BDFL = 'Guido van Rossum' - FLUFL = 'Barry Warsaw' -except Exception: - Name = sys.exc_info()[1] - -try: - Question = Enum('Question', 'who what when where why', module=__name__) -except Exception: - Question = sys.exc_info()[1] - -try: - Answer = Enum('Answer', 'him this then there because') -except Exception: - Answer = sys.exc_info()[1] - -try: - class WhatsIt(NamedTuple): - def what(self): - return self[0] - class ThatsIt(WhatsIt): - blah = 0 - bleh = 1 -except Exception: - ThatsIt = sys.exc_info()[1] - -# for doctests -try: - class Fruit(Enum): - tomato = 1 - banana = 2 - cherry = 3 -except Exception: - pass - -def test_pickle_dump_load(assertion, source, target=None, protocol=(0, HIGHEST_PROTOCOL)): - start, stop = protocol - failures = [] - for protocol in range(start, stop+1): - try: - if target is None: - assertion(loads(dumps(source, protocol=protocol)), source) - else: - assertion(loads(dumps(source, protocol=protocol)), target) - except Exception: - exc, tb = sys.exc_info()[1:] - failures.append('%2d: %s' %(protocol, exc)) - if failures: - raise ValueError('Failed with protocols: %s' % ', '.join(failures)) - -def test_pickle_exception(assertion, exception, obj, - protocol=(0, HIGHEST_PROTOCOL)): - start, stop = protocol - failures = [] - for protocol in range(start, stop+1): - try: - assertion(exception, dumps, obj, protocol=protocol) - except Exception: - exc = sys.exc_info()[1] - failures.append('%d: %s %s' % (protocol, exc.__class__.__name__, exc)) - if failures: - raise ValueError('Failed with protocols: %s' % ', '.join(failures)) - -if PY3: - from aenum.test_v3 import TestEnumV3, TestOrderV3, TestNamedTupleV3, TestStackoverflowAnswersV3, TestIssuesV3, TestExtendEnumV3 - from aenum import test_v3 - test_v3.IntStooges = IntStooges - test_v3.test_pickle_exception = test_pickle_exception - test_v3.test_pickle_dump_load = test_pickle_dump_load - -# for subclassing tests - -class classproperty(object): - - def __init__(self, fget=None, fset=None, fdel=None, doc=None): - self.fget = fget - self.fset = fset - self.fdel = fdel - if doc is None and fget is not None: - doc = fget.__doc__ - self.__doc__ = doc - - def __get__(self, instance, ownerclass): - return self.fget(ownerclass) - - -# tests -class TestOrder(TestCase): - """ - Test _order_ extra/missing members. - """ - - def test_same_members(self): - class Color(Enum): - _order_ = 'red green blue' - red = 1 - green = 2 - blue = 3 - - def test_same_members_with_aliases(self): - class Color(Enum): - _order_ = 'red green blue' - red = 1 - green = 2 - blue = 3 - verde = green - - def test_order_has_extra_members(self): - with self.assertRaisesRegex(TypeError, r'member order does not match _order_'): - class Color(Enum): - _order_ = 'red green blue purple' - red = 1 - green = 2 - blue = 3 - - def test_order_has_extra_members_with_aliases(self): - with self.assertRaisesRegex(TypeError, r'member order does not match _order_'): - class Color(Enum): - _order_ = 'red green blue purple' - red = 1 - green = 2 - blue = 3 - verde = green - - def test_enum_has_extra_members(self): - with self.assertRaisesRegex(TypeError, r'member order does not match _order_'): - class Color(Enum): - _order_ = 'red green blue' - red = 1 - green = 2 - blue = 3 - purple = 4 - - def test_enum_has_extra_members_with_aliases(self): - with self.assertRaisesRegex(TypeError, r'member order does not match _order_'): - class Color(Enum): - _order_ = 'red green blue' - red = 1 - green = 2 - blue = 3 - purple = 4 - verde = green - - def test_same_members_flag(self): - class Color(Flag): - _order_ = 'red green blue' - red = 1 - green = 2 - blue = 4 - - def test_same_members_with_aliases_flag(self): - class Color(Flag): - _order_ = 'red green blue' - red = 1 - green = 2 - blue = 4 - verde = green - - def test_order_has_extra_members_flag(self): - with self.assertRaisesRegex(TypeError, r'member order does not match _order_'): - class Color(Flag): - _order_ = 'red green blue purple' - red = 1 - green = 2 - blue = 4 - - def test_order_has_extra_members_with_aliases_flag(self): - with self.assertRaisesRegex(TypeError, r'member order does not match _order_'): - class Color(Flag): - _order_ = 'red green blue purple' - red = 1 - green = 2 - blue = 4 - verde = green - - def test_enum_has_extra_members_flag(self): - with self.assertRaisesRegex(TypeError, r'member order does not match _order_'): - class Color(Flag): - _order_ = 'red green blue' - red = 1 - green = 2 - blue = 4 - purple = 8 - - def test_enum_has_extra_members_with_aliases_flag(self): - with self.assertRaisesRegex(TypeError, r'member order does not match _order_'): - class Color(Flag): - _order_ = 'red green blue' - red = 1 - green = 2 - blue = 4 - purple = 8 - verde = green - - -class TestAutoValue(TestCase): - - def test_bare(self): - # - class BareEnum(Enum): - _order_ = 'ONE TWO THREE' - ONE = auto() - TWO = auto() - THREE = auto() - self.assertEqual(BareEnum.THREE.value, 3) - # - class BareIntEnum(IntEnum): - _order_ = 'ONE TWO THREE' - ONE = auto() - TWO = auto() - THREE = auto() - self.assertEqual(BareIntEnum.THREE, 3) - # - class BareFlag(Flag): - _order_ = 'ONE TWO THREE' - ONE = auto() - TWO = auto() - THREE = auto() - self.assertEqual(BareFlag.THREE.value, 4) - # - class BareIntFlag(IntFlag): - _order_ = 'ONE TWO THREE' - ONE = auto() - TWO = auto() - THREE = auto() - self.assertEqual(BareIntFlag.THREE, 4) - - def test_init_only_final(self): - # - class InitEnumValue(Enum): - _init_ = 'value description' - _order_ = 'ONE TWO THREE' - ONE = 'the loneliest number' - TWO = 'the number with you' - THREE = 'a triangle' - self.assertEqual(InitEnumValue.THREE.value, 3) - self.assertEqual(InitEnumValue.THREE.description, 'a triangle') - # - class InitEnum(Enum): - _init_ = 'value description' - _order_ = 'ONE TWO THREE' - ONE = 'the loneliest number' - TWO = 'the number with you' - THREE = 'a triangle' - self.assertEqual(InitEnum.THREE.value, 3) - self.assertEqual(InitEnum.THREE.description, 'a triangle') - # - class InitIntEnum(IntEnum): - _init_ = 'value description' - _order_ = 'ONE TWO THREE' - ONE = 'the loneliest number' - TWO = 'the number with you' - THREE = 'a triangle' - self.assertEqual(InitIntEnum.THREE, 3) - self.assertEqual(InitIntEnum.THREE.description, 'a triangle') - # - class InitFlag(Flag): - _init_ = 'value description' - _order_ = 'ONE TWO THREE' - ONE = 'the loneliest number' - TWO = 'the number with you' - THREE = 'a triangle' - self.assertEqual(InitFlag.THREE.value, 4) - self.assertEqual(InitFlag.THREE.description, 'a triangle') - # - class InitIntFlag(IntFlag): - _init_ = 'value description' - _order_ = 'ONE TWO THREE' - ONE = 'the loneliest number' - TWO = 'the number with you' - THREE = 'a triangle' - self.assertEqual(InitIntFlag.THREE, 4) - self.assertEqual(InitIntFlag.THREE.description, 'a triangle') - - def test_init_only_inherit(self): - # - class InitInheritEnum(Enum): - _init_ = 'value description' - # - class InitEnum(InitInheritEnum): - _order_ = 'ONE TWO THREE' - ONE = 'the loneliest number' - TWO = 'the number with you' - THREE = 'a triangle' - self.assertEqual(InitEnum.THREE.value, 3) - self.assertEqual(InitEnum.THREE.description, 'a triangle') - # - # - class InitInheritValueEnum(Enum): - _init_ = 'value description' - # - class InitEnum(InitInheritValueEnum): - _order_ = 'ONE TWO THREE' - ONE = 'the loneliest number' - TWO = 'the number with you' - THREE = 'a triangle' - self.assertEqual(InitEnum.THREE.value, 3) - self.assertEqual(InitEnum.THREE.description, 'a triangle') - # - class InitIntEnum(int, InitInheritValueEnum): - _order_ = 'ONE TWO THREE' - ONE = 'the loneliest number' - TWO = 'the number with you' - THREE = 'a triangle' - self.assertEqual(InitIntEnum.THREE, 3) - self.assertEqual(InitIntEnum.THREE.description, 'a triangle') - # - class InitInheritValueFlag(Flag): - _init_ = 'value description' - # - class InitFlag(InitInheritValueFlag): - _order_ = 'ONE TWO THREE' - ONE = 'the loneliest number' - TWO = 'the number with you' - THREE = 'a triangle' - self.assertEqual(InitFlag.THREE.value, 4) - self.assertEqual(InitFlag.THREE.description, 'a triangle') - # - class InitIntFlag(int, InitInheritValueFlag): - _order_ = 'ONE TWO THREE' - ONE = 'the loneliest number' - TWO = 'the number with you' - THREE = 'a triangle' - self.assertEqual(InitIntFlag.THREE, 4) - self.assertEqual(InitIntFlag.THREE.description, 'a triangle') - - def test_new_only_final(self): - # - class NewFinalEnum(Enum): - _order_ = 'ONE TWO THREE' - def __new__(cls, value): - member = object.__new__(cls) - member._value_ = value - member.proof = 'NFE1' - return member - ONE = auto() - TWO = auto() - THREE = auto() - self.assertEqual(NewFinalEnum.THREE.value, 3) - self.assertEqual(NewFinalEnum.TWO.proof, 'NFE1') - # - class NewFinalIntEnum(IntEnum): - _order_ = 'ONE TWO THREE' - def __new__(cls, value): - member = int.__new__(cls, value) - member._value_ = value - member.proof = 'NFE2' - return member - ONE = auto() - TWO = auto() - THREE = auto() - self.assertEqual(NewFinalIntEnum.THREE, 3) - self.assertEqual(NewFinalIntEnum.TWO.proof, 'NFE2') - # - class NewFinalFlag(Flag): - _order_ = 'ONE TWO THREE' - def __new__(cls, value): - member = object.__new__(cls) - member._value_ = value - member.proof = 'NFE3' - return member - ONE = auto() - TWO = auto() - THREE = auto() - self.assertEqual(NewFinalFlag.THREE.value, 4) - self.assertEqual(NewFinalFlag.TWO.proof, 'NFE3') - # - class NewFinalIntFlag(IntFlag): - _order_ = 'ONE TWO THREE' - def __new__(cls, value): - member = int.__new__(cls, value) - member._value_ = value - member.proof = 'NFE4' - return member - ONE = auto() - TWO = auto() - THREE = auto() - self.assertEqual(NewFinalIntFlag.THREE, 4) - self.assertEqual(NewFinalIntFlag.TWO.proof, 'NFE4') - # - class NewFinalStrEnum(str, Enum): - # - _order_ = "AllReset Bright FG_Cyan BG_Black" - # - def __new__(cls, value, code, description): - str_value = '\x1b[%sm' % code - obj = str.__new__(cls, str_value) - obj._value_ = value - obj.code = code - obj.description = description - return obj - # - __str__ = str.__str__ - # - AllReset = '0', 'reset all (colors and brightness)' - Bright = '1', 'bright lights!' - FG_Cyan = '36', 'cyan' - BG_Black = '40', 'black' - self.assertEqual(NewFinalStrEnum.FG_Cyan.value, 3) - self.assertEqual(NewFinalStrEnum.BG_Black.value, 4) - self.assertEqual(NewFinalStrEnum.AllReset.code, '0') - self.assertEqual(NewFinalStrEnum.Bright.description, 'bright lights!') - # - class NewFinalStrFlag(str, Flag): - # - _order_ = "AllReset Bright FG_Cyan BG_Black" - # - def __new__(cls, value, code, description): - str_value = '\x1b[%sm' % code - obj = str.__new__(cls, str_value) - obj._value_ = value - obj.code = code - obj.description = description - return obj - # - __str__ = str.__str__ - # - AllReset = '0', 'reset all (colors and brightness)' - Bright = '1', 'bright lights!' - FG_Cyan = '36', 'cyan' - BG_Black = '40', 'black' - self.assertEqual(NewFinalStrFlag.FG_Cyan.value, 4) - self.assertEqual(NewFinalStrFlag.BG_Black.value, 8) - self.assertEqual(NewFinalStrFlag.AllReset.code, '0') - self.assertEqual(NewFinalStrFlag.Bright.description, 'bright lights!') - - def test_new_only_inherited(self): - # - class NewInheritEnum(Enum): - def __new__(cls, value): - if cls._member_type_ is int: - member = int.__new__(cls, value*2) - else: - member = object.__new__(cls) - member._value_ = value * 2 - member.proof = 'NIE' - return member - # - class NewFinalEnum(NewInheritEnum): - _order_ = 'ONE TWO THREE' - ONE = auto() - TWO = auto() - THREE = auto() - self.assertEqual(NewFinalEnum.THREE.value, 6) - self.assertEqual(NewFinalEnum.TWO.proof, 'NIE') - # - class NewFinalIntEnum(int, NewInheritEnum): - _order_ = 'ONE TWO THREE' - ONE = auto() - TWO = auto() - THREE = auto() - self.assertEqual(NewFinalIntEnum.THREE, 6) - self.assertEqual(NewFinalIntEnum.TWO.proof, 'NIE') - # - class NewInheritFlag(Flag): - def __new__(cls, value): - if cls._member_type_ is int: - member = int.__new__(cls, value*2) - else: - member = object.__new__(cls) - member._value_ = value * 2 - member.proof = 'NIE' - return member - # - class NewFinalFlag(NewInheritFlag): - _order_ = 'ONE TWO THREE' - ONE = auto() - TWO = auto() - THREE = auto() - self.assertEqual(NewFinalFlag.THREE.value, 8) - self.assertEqual(NewFinalFlag.TWO.proof, 'NIE') - # - class NewFinalIntFlag(int, NewInheritFlag): - _order_ = 'ONE TWO THREE' - ONE = auto() - TWO = auto() - THREE = auto() - self.assertEqual(NewFinalIntFlag.THREE, 8) - self.assertEqual(NewFinalIntFlag.TWO.proof, 'NIE') - - def test_init_new_only(self): - # - class InitNewEnum(Enum): - _init_ = "value description" - _order_ = 'ONE TWO THREE' - def __new__(cls, value, *args): - member = object.__new__(cls) - member._value_ = value - member.proof = 'INE1' - return member - ONE = 'the loneliest number' - TWO = 'the number with you' - THREE = 'a triangle' - self.assertEqual(InitNewEnum.THREE.value, 3) - self.assertEqual(InitNewEnum.THREE.description, 'a triangle') - self.assertEqual(InitNewEnum.TWO.proof, 'INE1') - # - class InitNewIntEnum(IntEnum): - _init_ = "value description" - _order_ = 'ONE TWO THREE' - def __new__(cls, value, *args): - member = int.__new__(cls, value) - member._value_ = value - member.proof = 'INE2' - return member - ONE = 'the loneliest number' - TWO = 'the number with you' - THREE = 'a triangle' - self.assertEqual(InitNewIntEnum.THREE, 3) - self.assertEqual(InitNewIntEnum.THREE.description, 'a triangle') - self.assertEqual(InitNewIntEnum.TWO.proof, 'INE2') - # - class InitNewFlag(Flag): - _init_ = "value description" - _order_ = 'ONE TWO THREE' - def __new__(cls, value, *args): - member = object.__new__(cls) - member._value_ = value - member.proof = 'INE3' - return member - ONE = 'the loneliest number' - TWO = 'the number with you' - THREE = 'a triangle' - self.assertEqual(InitNewFlag.THREE.value, 4) - self.assertEqual(InitNewFlag.THREE.description, 'a triangle') - self.assertEqual(InitNewFlag.TWO.proof, 'INE3') - # - class InitNewIntFlag(IntFlag): - _init_ = "value description" - _order_ = 'ONE TWO THREE' - def __new__(cls, value, *args): - member = int.__new__(cls, value) - member._value_ = value - member.proof = 'INE4' - return member - ONE = 'the loneliest number' - TWO = 'the number with you' - THREE = 'a triangle' - self.assertEqual(InitNewIntFlag.THREE, 4) - self.assertEqual(InitNewIntFlag.THREE.description, 'a triangle') - self.assertEqual(InitNewIntFlag.TWO.proof, 'INE4') - - def test_init_new_inherit(self): - # - class InitNew(Enum): - _init_ = "value description" - def __new__(cls, value, *args): - member = object.__new__(cls) - member._value_ = value - member.proof = 'IN' - return member - # - class InitNewEnum(InitNew): - _order_ = 'ONE TWO THREE' - ONE = 'the loneliest number' - TWO = 'the number with you' - THREE = 'a triangle' - self.assertEqual(InitNewEnum.THREE.value, 3) - self.assertEqual(InitNewEnum.THREE.description, 'a triangle') - self.assertEqual(InitNewEnum.TWO.proof, 'IN') - # - class InitNewInt(Enum): - _init_ = "value description" - def __new__(cls, value, *args): - member = int.__new__(cls, value) - member._value_ = value - member.proof = 'IN' - return member - # - class InitNewIntEnum(int, InitNewInt): - _order_ = 'ONE TWO THREE' - ONE = 'the loneliest number' - TWO = 'the number with you' - THREE = 'a triangle' - self.assertEqual(InitNewIntEnum.THREE, 3) - self.assertEqual(InitNewIntEnum.THREE.description, 'a triangle') - self.assertEqual(InitNewIntEnum.TWO.proof, 'IN') - # - class InitNewFlagBase(Flag): - _init_ = "value description" - def __new__(cls, value, *args): - member = object.__new__(cls) - member._value_ = value - member.proof = 'IN' - return member - # - class InitNewFlag(InitNewFlagBase): - _order_ = 'ONE TWO THREE' - ONE = 'the loneliest number' - TWO = 'the number with you' - THREE = 'a triangle' - self.assertEqual(InitNewFlag.THREE.value, 4) - self.assertEqual(InitNewFlag.THREE.description, 'a triangle') - self.assertEqual(InitNewFlag.TWO.proof, 'IN') - # - class InitNewIntFlagBase(int, Flag): - _init_ = "value description" - def __new__(cls, value, *args): - member = int.__new__(cls, value) - member._value_ = value - member.proof = 'IN' - return member - # - class InitNewIntFlag(InitNewIntFlagBase): - _order_ = 'ONE TWO THREE' - ONE = 'the loneliest number' - TWO = 'the number with you' - THREE = 'a triangle' - self.assertEqual(InitNewIntFlag.THREE, 4) - self.assertEqual(InitNewIntFlag.THREE.description, 'a triangle') - self.assertEqual(InitNewIntFlag.TWO.proof, 'IN') - - -class TestHelpers(TestCase): - # _is_descriptor, _is_sunder, _is_dunder - - def test_is_descriptor(self): - class foo: - pass - for attr in ('__get__','__set__','__delete__'): - obj = foo() - self.assertFalse(aenum._is_descriptor(obj)) - setattr(obj, attr, 1) - self.assertTrue(aenum._is_descriptor(obj)) - - def test_is_sunder(self): - for s in ('_a_', '_aa_'): - self.assertTrue(aenum._is_sunder(s)) - - for s in ('a', 'a_', '_a', '__a', 'a__', '__a__', '_a__', '__a_', '_', - '__', '___', '____', '_____',): - self.assertFalse(aenum._is_sunder(s)) - - def test_is_dunder(self): - for s in ('__a__', '__aa__'): - self.assertTrue(aenum._is_dunder(s)) - for s in ('a', 'a_', '_a', '__a', 'a__', '_a_', '_a__', '__a_', '_', - '__', '___', '____', '_____',): - self.assertFalse(aenum._is_dunder(s)) - - def test_auto(self): - def tester(first, op, final, second=None): - if second is None: - left = auto() - value = op(left) - left.value = first - self.assertEqual(value.value, final, - "%s %r -> %r != %r" % (op.__name__, first, value, final)) - else: - left = first - right = auto() - value = op(left, right) - right.value = second - self.assertEqual(value.value, final, - "forward: %r %s %r -> %r != %r" % (first, op.__name__, second, value.value, final)) - left = auto() - right = second - value = op(left, right) - left.value = first - self.assertEqual(value.value, final, - "reversed: %r %s %r -> %r != %r" % (second, op.__name__, first, value.value, final)) - for args in ( - (1, _abs_, abs(1)), - (-3, _abs_, abs(-3)), - (1, _add_, 1+2, 2), - (25, _floordiv_, 25 // 5, 5), - (49, _truediv_, 49 / 9, 9), - (6, _mod_, 6 % 9, 9), - (5, _lshift_, 5 << 2, 2), - (5, _rshift_, 5 >> 2, 2), - (3, _mul_, 3 * 6, 6), - (5, _neg_, -5), - (-4, _pos_, +(-4)), - (2, _pow_, 2**5, 5), - (7, _sub_, 7 - 10, 10), - (1, _or_, 1 | 2, 2), - (3, _xor_, 3 ^ 6, 6), - (3, _and_, 3 & 6, 6), - (7, _inv_, ~7), - ('a', _add_, 'a'+'b', 'b'), - ('a', _mul_, 'a' * 3, 3), - ): - tester(*args) - # operator.div is gone in 3 - if PY2: - tester(12, _div_, 12 // 5, 5) - # strings are a pain - left = auto() - right = 'eggs' - value = _mod_(left, right) - left.value = 'I see 17 %s!' - self.assertEqual(value.value, 'I see 17 %s!' % 'eggs') - - def test_constant(self): - errors = [] - def tester(first, op, final, second=None): - if second is None: - primary = constant(first) - secondary = constant(op(primary)) - if secondary.value != final: - errors.append( - "%s %r -> %r != %r" % (op.__name__, first, secondary.value, final), - ) - else: - left = constant(first) - right = second - value = op(left, right) - if value != final: - errors.append( - "forward: %r %s %r -> %r != %r" % (first, op.__name__, second, value, final), - ) - left = first - right = constant(second) - value = op(left, right) - if value != final: - errors.append( - "reversed: %r %s %r -> %r != %r" % (second, op.__name__, first, value, final), - ) - for args in ( - (1, _abs_, abs(1)), - (-3, _abs_, abs(-3)), - (1, _add_, 1+2, 2), - (25, _floordiv_, 25 // 5, 5), - (49, _truediv_, 49 / 9, 9), - (6, _mod_, 6 % 9, 9), - (5, _lshift_, 5 << 2, 2), - (5, _rshift_, 5 >> 2, 2), - (3, _mul_, 3 * 6, 6), - (5, _neg_, -5), - (-4, _pos_, +(-4)), - (2, _pow_, 2**5, 5), - (7, _sub_, 7 - 10, 10), - (1, _or_, 1 | 2, 2), - (3, _xor_, 3 ^ 6, 6), - (3, _and_, 3 & 6, 6), - (7, _inv_, ~7), - ('a', _add_, 'a'+'b', 'b'), - ('a', _mul_, 'a' * 3, 3), - ): - tester(*args) - # operator.div is gone in 3 - if PY2: - tester(12, _div_, 12 // 5, 5) - # strings are a pain - left = constant('I see 17 %s!') - right = 'eggs' - value = _mod_(left, right) - if value != 'I see 17 %s!' % 'eggs': - errors.append("'I see 17 eggs!' != %r" % value) - if errors: - print() - for error in errors: - print(error) - self.assertTrue(False) - - -class TestEnumType(TestCase): - - def test_immutability(self): - class Hah(object): - @classproperty - def all_values(cls): - return [m.value for m in cls] - class Huh(Hah, Enum): - one = 1 - two = 2 - self.assertRaisesRegex(AttributeError, 'cannot rebind property', setattr, Huh, 'value', 'boom') - self.assertRaisesRegex(AttributeError, 'cannot delete property', delattr, Huh, 'value') - self.assertRaisesRegex(AttributeError, 'cannot set attribute', setattr, Huh.one, 'value', 'boom') - self.assertRaisesRegex(AttributeError, 'cannot delete attribute', delattr, Huh.two, 'value') - self.assertEqual(Huh.one.value, 1) - self.assertEqual(Huh.two.value, 2) - self.assertEqual(Huh.all_values, [1, 2]) - setattr(Huh, 'all_values', 99) - self.assertEqual(Huh.all_values, 99) - - def test_enum_shadow_base(self): - class hohum(object): - def cyan(self): - "cyanize a color" - return self.value * 'cyan' - @property - def azure(self): - return 'azure ' + self.name - class Color(hohum, Enum): - red = 1 - green = 2 - blue = 3 - cyan = 4 - azure = 5 - self.assertEqual(len(Color), 5) - self.assertEqual(list(Color), [Color.red, Color.green, Color.blue, Color.cyan, Color.azure]) - self.assertRaisesRegex(AttributeError, 'no attribute .cyan.', lambda: Color.blue.cyan) - self.assertEqual(Color.red.azure, 'azure red') - - -class TestEnum(TestCase): - - def setUp(self): - class Season(Enum): - SPRING = 1 - SUMMER = 2 - AUTUMN = 3 - WINTER = 4 - self.Season = Season - - class Konstants(float, Enum): - E = 2.7182818 - PI = 3.1415926 - TAU = 2 * PI - self.Konstants = Konstants - - class Grades(IntEnum): - A = 5 - B = 4 - C = 3 - D = 2 - F = 0 - self.Grades = Grades - - class Directional(str, Enum): - EAST = 'east' - WEST = 'west' - NORTH = 'north' - SOUTH = 'south' - self.Directional = Directional - - from datetime import date - class Holiday(date, Enum): - NEW_YEAR = 2013, 1, 1 - IDES_OF_MARCH = 2013, 3, 15 - self.Holiday = Holiday - - def test_set_name(self): - class Descriptor(object): - name = None - def __get__(self, instance, owner_class=None): - if instance is None: - return self - else: - return instance.__dict__[self.name] - def __set__(self, instance, value): - instance.__dict__[self.name] = value - def __set_name__(self, owner, name): - self.name = name - # - class AnEnum(Enum): - ONE = 'one' - two = Descriptor() - # - self.assertEqual(list(AnEnum), [AnEnum.ONE]) - self.assertEqual(AnEnum.two.name, 'two') - AnEnum.ONE.two = 'three' - self.assertEqual(AnEnum.ONE.two, 'three') - self.assertEqual(AnEnum.ONE.__dict__['two'], 'three') - - def test_private_names(self): - class Private(Enum): - __corporal = 'Radar' - __major_ = 'Hoolihan' - self.assertEqual(len(Private), 0) - self.assertEqual(Private._Private__corporal, 'Radar') - self.assertFalse(isinstance(Private._Private__corporal, Enum)) - self.assertEqual(Private._Private__major_, 'Hoolihan') - self.assertFalse(isinstance(Private._Private__major_, Enum)) - - def test_new_with_keywords(self): - class Huh(IntEnum): - __order__ = 'PLAIN BOLD_ITALIC HIGHLIGHT' - def __new__(cls, docstring, open=None, close=None): - value = len(cls.__members__) - member = int.__new__(cls, value) - if open and close is None: - close = open - member.open = open - member.close = close - member.__doc__ = docstring - member._value_ = value - return member - PLAIN = 'normal' - BOLD_ITALIC = '***really super important***', '***' - HIGHLIGHT = 'please ==take notice==', '==', '==' - p = Huh.PLAIN - self.assertTrue(type(p) is Huh, type(p)) - self.assertEqual( - (p.value, p.__doc__, p.open, p.close), - (0, 'normal', None, None), - ) - bi = Huh.BOLD_ITALIC - self.assertEqual( - (bi.value, bi.__doc__, bi.open, bi.close), - (1, '***really super important***', '***', '***'), - ) - h = Huh.HIGHLIGHT - self.assertEqual( - (h.value, h.__doc__, h.open, h.close), - (2, 'please ==take notice==', '==', '=='), - ) - - def test_members_is_ordereddict_if_ordered(self): - class Ordered(Enum): - __order__ = 'first second third' - first = 'bippity' - second = 'boppity' - third = 'boo' - self.assertTrue(type(Ordered.__members__) is OrderedDict) - - def test_members_is_ordereddict_if_not_ordered(self): - class Unordered(Enum): - this = 'that' - these = 'those' - self.assertTrue(type(Unordered.__members__) is OrderedDict) - - def test_enum_in_enum_out(self): - Season = self.Season - self.assertTrue(Season(Season.WINTER) is Season.WINTER) - - def test_enum_value(self): - Season = self.Season - self.assertEqual(Season.SPRING.value, 1) - - def test_intenum_value(self): |