| Server IP : 178.105.222.151 / Your IP : 216.73.216.38 Web Server : nginx/1.28.3 System : Linux MNK 7.0.0-15-generic #15-Ubuntu SMP PREEMPT_DYNAMIC Wed Apr 22 16:06:43 UTC 2026 x86_64 User : www-data ( 33) PHP Version : 8.5.4 Disable Function : NONE MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : OFF | Sudo : ON | Pkexec : OFF Directory : /lib/python3/dist-packages/constantly/test/__pycache__/ |
Upload File : |
+
��3i� � � � R t ^ RIHtHt ^ RIHt ^ RIHtHtH t H
t
H t H t ! R R]4 t
! R R]4 t ! R R ]]4 t ! R
R ]]4 t ! R R
]4 t ! R R]]]4 t ! R R]]4 t ! R R]]4 t ! R R]]4 t ! R R]]4 t ! R R]4 t ! R R]4 t ! R R ]4 t ! R R ]
4 t ! R R!] 4 t R"# )#z
Unit tests for L{constantly}.
)�division�absolute_import)�TestCase)�
NamedConstant�Names�
ValueConstant�Values� FlagConstant�Flagsc �H a � ] tR t^t o RtR tR tR tR tR t R t
Rt V t R # )
�NamedConstantTestsz_
Tests for the L{constantly.NamedConstant} class which is used
to represent individual values.
c �0 � ! R R\ 4 pWn R# )z>
Create a dummy container into which constants can be placed.
c � � ] tR t^tRtR# )�%NamedConstantTests.setUp.<locals>.foo� N)�__name__�
__module__� __qualname__�__firstlineno__�__static_attributes__r � �@/usr/lib/python3/dist-packages/constantly/test/test_constants.py�foor s � � r r N)r � container)�selfr s & r �setUp�NamedConstantTests.setUp s � � �%� � �r c � � \ 4 pVP V P RR4 V P RVP 4 R# )zr
The C{name} attribute of a L{NamedConstant} refers to the value passed
for the C{name} parameter to C{_realize}.
�barN)r �_realizer � assertEqual�name�r r! s & r � test_name� NamedConstantTests.test_name s3 � �
��� �
�
�d�n�n�e�T�2� ����� � �*r c � � \ 4 pVP V P RR4 V P R\ V4 4 R# )z�
The string representation of an instance of L{NamedConstant} includes
the container the instances belongs to as well as the instance's name.
r Nz <foo=bar>)r r r r �reprr" s & r �test_representation�&NamedConstantTests.test_representation* s3 � �
��� �
�
�d�n�n�e�T�2� ����d�4�j�1r c � � \ 4 pVP V P RR4 V P W8H 4 V P W8g 4 R# )z7
A L{NamedConstant} instance compares equal to itself.
r N)r r r �
assertTrue� assertFalser" s & r �
test_equality� NamedConstantTests.test_equality4 s= � � ��� �
�
�d�n�n�e�T�2� ���� �%� ���� �&r c �� � \ 4 pVP V P RR4 \ 4 pVP V P RR4 V P W8H 4 V P W8g 4 R# )zN
Two different L{NamedConstant} instances do not compare equal to each
other.
r N)r r r r+ r* �r �first�seconds & r �test_nonequality�#NamedConstantTests.test_nonequality> sX � �
���
���t�~�~�u�d�3� � ���������t�4� ���� �)� �����(r c �� � \ 4 pVP V P RR4 \ 4 pVP V P RR4 V P \ V4 \ V4 4 R# )z�
Because two different L{NamedConstant} instances do not compare as
equal to each other, they also have different hashes to avoid
collisions when added to a C{dict} or C{set}.
r N)r r r �assertNotEqual�hashr/ s & r � test_hash� NamedConstantTests.test_hashK sR � � ���
���t�~�~�u�d�3� � ���������t�4� ���D��K��f� �6r )r N)
r r r r �__doc__r r# r' r, r2 r7 r �__classdictcell__��
__classdict__s @r r r s- �� � �� �+�2�'�
)�
7�
7r r c �0 a � ] tR t^Yt o RtR tR tRtV tR# )�_ConstantsTestsMixinzP
Mixin defining test helpers common to multiple types of constants
collections.
c �v � V P \ V4 pV P VR, \ V4 4 R# )z�
Assert that an attempt to instantiate the constants class raises
C{TypeError}.
@param name: A C{str} giving the name of the constants collection.
@param cls: The constants class to test.
z may not be instantiated.N)� assertRaises� TypeErrorr �str)r r! �cls�excs &&& r �_notInstantiableTest�)_ConstantsTestsMixin._notInstantiableTest^ s0 � � � � � �3�/�� ���� ;�;�S��X�Fr c �n � VP p\ W4 VP pV P W44 R# )a#
Assert that C{container._enumerants} does not change as a side-effect
of one of its attributes being accessed.
@param container: A L{_ConstantsContainer} subclass which will be
tested.
@param constantName: The name of one of the constants which is an an
attribute of C{container}.
N)� _enumerants�getattr�assertIdentical)r r � constantNamer0 r1 s &&& r �_initializedOnceTest�)_ConstantsTestsMixin._initializedOnceTestj s2 � � �%�%�� � �(��&�&�� � � �U�+r r N) r r r r r9 rE rL r r: r; s @r r> r> Y s �� � �� G�,� ,r r> c � a � ] tR t^t o RtR tR tR tR tR t R t
R t R t R
t
R tR tR
tR tR tR tR tRtV tR# )�
NamesTestszS
Tests for L{constantly.Names}, a base class for containers of
related constaints.
c �0 � ! R R\ 4 pWn R# )z�
Create a fresh new L{Names} subclass for each unit test to use. Since
L{Names} is stateful, re-using the same subclass across test methods
makes exercising all of the implementation code paths difficult.
c �` � ] tR t^�tRt]! 4 t]! 4 t]! 4 t]! 4 t ]
! 4 t Rt R# )� NamesTests.setUp.<locals>.METHODzI
A container for some named constants to use in unit tests for
L{Names}.
r N)
r r r r r9 r �GET�PUT�POST�DELETE�object�extrar r r r �METHODrR � s, � �
� �/�C� �/�C� �?�D�"�_�F��H�Er rY N)r rY )r rY s & r r �NamesTests.setUp� s � �
�U�
� � r c �> � V P RV P 4 R# )zU
A subclass of L{Names} raises C{TypeError} if an attempt is made to
instantiate it.
rY N)rE rY �r s &r �test_notInstantiable� NamesTests.test_notInstantiable� � � �
�!�!�(�D�K�K�8r c �. � V P \ V P R4 4 V P \ V P R4 4 V P \ V P R4 4 V P \ V P R4 4 R# )z�
Each name associated with a L{NamedConstant} instance in the definition
of a L{Names} subclass is available as an attribute on the resulting
class.
rS rT rU rV N)r* �hasattrrY r\ s &r �test_symbolicAttributes�"NamesTests.test_symbolicAttributes� s` � �
����� � �U�3�4� ����� � �U�3�4� ����� � �V�4�5� ����� � �X�6�7r c �P � V P \ V P R4 4 R# )z
As usual, names not defined in the class scope of a L{Names}
subclass are not available as attributes on the resulting class.
r N)r+ ra rY r\ s &r �test_withoutOtherAttributes�&NamesTests.test_withoutOtherAttributes� � � �
�������e�4�5r c �d � V P R\ V P P 4 4 R# )z�
The string representation of a constant on a L{Names} subclass includes
the name of the L{Names} subclass and the name of the constant itself.
z <METHOD=GET>N)r r& rY rS r\ s &r r' � NamesTests.test_representation� s! � �
��� ��d�k�k�o�o�)>�?r c � � V P P R4 pV P V P P V4 R# )zA
Constants can be looked up by name using L{Names.lookupByName}.
rS N)rY � lookupByNamerJ rS �r �methods & r �test_lookupByName� NamesTests.test_lookupByName� s0 � � ���)�)�%�0�� � � �T�[�[�_�_�f�5r c �^ � V P \ V P P R4 V P \ V P P R4 V P \ V P P R4 V P \ V P P R4 R# )ze
Names not defined with a L{NamedConstant} instance cannot be looked up
using L{Names.lookupByName}.
rk �__init__r rX N)r@ �
ValueErrorrY rk r\ s &r �test_notLookupMissingByName�&NamesTests.test_notLookupMissingByName� st � �
���*�d�k�k�&>�&>��O� ���*�d�k�k�&>�&>�
�K� ���*�d�k�k�&>�&>��F� ���*�d�k�k�&>�&>��Hr c �f � V P RV P P P 4 R# )zQ
The C{name} attribute of one of the named constants gives that
constant's name.
rS N)r rY rS r! r\ s &r r# �NamesTests.test_name� s" � �
����� � ��� 4� 4�5r c �z � V P V P P V P P 4 R# )z}
Repeated access of an attribute associated with a L{NamedConstant}
value in a L{Names} subclass results in the same object.
N)rJ rY rS r\ s &r �test_attributeIdentity�!NamesTests.test_attributeIdentity� s$ � �
� � �T�[�[�_�_�d�k�k�o�o�>r c � � \ V P P 4 4 pV P V P P V P P
V P P V P P .V4 R# )z|
L{Names.iterconstants} returns an iterator over all of the constants
defined in the class, in the order they were defined.
N)�listrY �
iterconstantsr rS rT rU rV �r � constantss & r �test_iterconstants� NamesTests.test_iterconstants� s_ � �
����2�2�4�5� � ���
�[�[�_�_�d�k�k�o�o�
�[�[�
�
�t�{�{� 1� 1�
3� � r c � � \ V P P 4 4 pV P V P P V^ , 4 V P V P P
V^, 4 V P V P P V^, 4 V P V P P V^, 4 R# )zp
The constants returned from L{Names.iterconstants} are identical to the
constants accessible using attributes.
N)r{ rY r| rJ rS rT rU rV r} s & r �#test_attributeIterconstantsIdentity�.NamesTests.test_attributeIterconstantsIdentity� s� � �
����2�2�4�5� � � � �T�[�[�_�_�i��l�;� � � �T�[�[�_�_�i��l�;� � � �T�[�[� -� -�y��|�<� � � �T�[�[� /� /��1� �>r c � � \ V P P 4 4 p\ V P P 4 4 pV P V^ , V^ , 4 V P V^, V^, 4 V P V^, V^, 4 V P V^, V^, 4 R# )z_
The constants returned from L{Names.iterconstants} are identical on
each call to that method.
N)r{ rY r| rJ �r r~ �agains & r �test_iterconstantsIdentity�%NamesTests.test_iterconstantsIdentity� s� � �
����2�2�4�5� ��T�[�[�.�.�0�1�� � � �U�1�X�y��|�4� � � �U�1�X�y��|�4� � � �U�1�X�y��|�4� � � �U�1�X�y��|�4r c �> � V P V P R4 R# )zV
L{Names._enumerants} is initialized once and its value re-used on
subsequent access.
rS N)rL rY r\ s &r �test_initializedOnce� NamesTests.test_initializedOnce s � �
�!�!�$�+�+�u�5r c � a � ! V 3R lR\ 4 pS P S P P VP 4 R# )z�
A constant defined on a L{Names} subclass may be set as an attribute of
another class and then retrieved using that attribute.
c �F <� ] tR tRt Z P P
tRtR# )�8NamesTests.test_asForeignClassAttribute.<locals>.Anotheri r N�r r r r rY rS � somethingr r\ s �r �Anotherr� � �� � � � ���Ir r� N�rW rJ rY rS r� �r r� s f r � test_asForeignClassAttribute�'NamesTests.test_asForeignClassAttribute
s/ �� �
(�f� (�
� � �T�[�[�_�_�g�.?�.?�@r c � a � ! V 3R lR\ 4 pS P S P P V! 4 P 4 R# )z�
A constant defined on a L{Names} subclass may be set as an attribute of
another class and then retrieved from an instance of that class using
that attribute.
c �F <� ] tR tRt Z P P
tRtR# )�CNamesTests.test_asForeignClassAttributeViaInstance.<locals>.Anotheri r Nr� r\ s �r r� r� r� r r� Nr� r� s f r �'test_asForeignClassAttributeViaInstance�2NamesTests.test_asForeignClassAttributeViaInstance s1 �� � (�f� (�
� � �T�[�[�_�_�g�i�.A�.A�Br c �v a � V 3R lpS P \ V4 pS P R\ V4 4 R# )z�
It is explicitly disallowed (via a L{ValueError}) to use a constant
defined on a L{Names} subclass as the value of an attribute of another
L{Names} subclass.
c �, <� ! V3R lR\ 4 p R# )c �F <� ] tR tRt Z P P
tRtR# )�XNamesTests.test_notAsAlternateContainerAttribute.<locals>.defineIt.<locals>.AnotherNamesi+ r Nr� r\ s �r � AnotherNamesr� + s �� � �K�K�O�O� r r� N)r )r� r s �r �defineIt�BNamesTests.test_notAsAlternateContainerAttribute.<locals>.defineIt* s �� �
,�u�
,r zDCannot use <METHOD=GET> as the value of an attribute on AnotherNamesN)r@ rr r rB )r r� rD s f r �%test_notAsAlternateContainerAttribute�0NamesTests.test_notAsAlternateContainerAttribute$ s6 �� � ,� � � �
�H�5�� ���
� ��H� r )rY N)r r r r r9 r r] rb re r' rn rs r# rx r r� r� r� r� r� r� r r: r; s @r rO rO sc �� � �� �*9� 8�6�@�6�I�6�?� � ?�
5�6�A� C�� r rO c � a � ] tR tRt o RtR tR tR tR tR t R t
R t R
t R t
R tR
tR tR tR tR tR tRtV tR# )� ValuesTestsi6 zi
Tests for L{constantly.Names}, a base class for containers of
related constaints with arbitrary values.
c �0 � ! R R\ 4 pWn R# )z�
Create a fresh new L{Values} subclass for each unit test to use. Since
L{Values} is stateful, re-using the same subclass across test methods
makes exercising all of the implementation code paths difficult.
c �6 � ] tR tRt]! R4 t]! R4 tRtR# )�!ValuesTests.setUp.<locals>.STATUSiA �200�404r N)r r r r r �OK� NOT_FOUNDr r r r �STATUSr� A s � � �u�%�B�%�e�,�Ir r� N)r r� )r r� s & r r �ValuesTests.setUp; s � � -�V� -� � r c �> � V P RV P 4 R# )zV
A subclass of L{Values} raises C{TypeError} if an attempt is made to
instantiate it.
r� N)rE r� r\ s &r r] � ValuesTests.test_notInstantiableH r_ r c � � V P \ V P R4 4 V P \ V P R4 4 R# )z�
Each name associated with a L{ValueConstant} instance in the definition
of a L{Values} subclass is available as an attribute on the resulting
class.
r� r� N)r* ra r� r\ s &r rb �#ValuesTests.test_symbolicAttributesP s2 � �
����� � �T�2�3� ����� � �[�9�:r c �P � V P \ V P R4 4 R# )z�
As usual, names not defined in the class scope of a L{Values}
subclass are not available as attributes on the resulting class.
r N)r+ ra r� r\ s &r re �'ValuesTests.test_withoutOtherAttributesZ rg r c �d � V P R\ V P P 4 4 R# )z�
The string representation of a constant on a L{Values} subclass
includes the name of the L{Values} subclass and the name of the
constant itself.
z <STATUS=OK>N)r r& r� r� r\ s &r r' � ValuesTests.test_representationb s! � �
��� ��T�[�[�^�^�(<�=r c � � V P P R4 pV P V P P V4 R# )zB
Constants can be looked up by name using L{Values.lookupByName}.
r� N)r� rk rJ r� rl s & r rn � ValuesTests.test_lookupByNamek s0 � � ���)�)�$�/�� � � �T�[�[�^�^�V�4r c � � V P \ V P P R4 V P \ V P P R4 V P \ V P P R4 R# )zf
Names not defined with a L{ValueConstant} instance cannot be looked up
using L{Values.lookupByName}.
rk rq r N)r@ rr r� rk r\ s &r rs �'ValuesTests.test_notLookupMissingByNames sX � �
���*�d�k�k�&>�&>��O� ���*�d�k�k�&>�&>�
�K� ���*�d�k�k�&>�&>��Fr c � � V P P R4 pV P V P P V4 R# )z�
Constants can be looked up by their associated value, defined by the
argument passed to L{ValueConstant}, using L{Values.lookupByValue}.
r� N)r� �
lookupByValuerJ r� )r �statuss & r �test_lookupByValue� ValuesTests.test_lookupByValue} s0 � �
���*�*�5�1�� � � �T�[�[�^�^�V�4r c �z � ! R R\ 4 pV P VP ^ 4 VP 4 R# )z�
If more than one constant is associated with a particular value,
L{Values.lookupByValue} returns whichever of them is defined first.
c �: � ] tR tRtRt]! ^ 4 t]! ^ 4 tRtR# )�BValuesTests.test_lookupDuplicateByValue.<locals>.TRANSPORT_MESSAGEi� z.
Message types supported by an SSH transport.
r N) r r r r r9 r �KEX_DH_GEX_REQUEST_OLD�
KEXDH_INITr r r r �TRANSPORT_MESSAGEr� � s � �
� &3�2�%6� "�&�r�*�Jr r� N)r rJ r� r� )r r� s & r �test_lookupDuplicateByValue�'ValuesTests.test_lookupDuplicateByValue� s5 � �
+�� +�
� � � � +� +�B� /� � 4� 4� 6r c � � V P \ V P P R4 V P \ V P P ^�4 V P \ V P P R4 R# )zm
L{Values.lookupByValue} raises L{ValueError} when called with a value
with which no constant is associated.
r� z200.1N)r@ rr r� r� r\ s &r � test_notLookupMissingByValue�(ValuesTests.test_notLookupMissingByValue� sX � �
���*�d�k�k�&?�&?��F� ���*�d�k�k�&?�&?��E� ���*�d�k�k�&?�&?��Ir c �f � V P RV P P P 4 R# )�K
The C{name} attribute of one of the constants gives that constant's
name.
r� N)r r� r� r! r\ s &r r# �ValuesTests.test_name� s" � �
����t�{�{�~�~� 2� 2�3r c �z � V P V P P V P P 4 R# )z~
Repeated access of an attribute associated with a L{ValueConstant}
value in a L{Values} subclass results in the same object.
N)rJ r� r� r\ s &r rx �"ValuesTests.test_attributeIdentity� s$ � �
� � �T�[�[�^�^�T�[�[�^�^�<r c �� � \ V P P 4 4 pV P V P P V P P
.V4 R# )z}
L{Values.iterconstants} returns an iterator over all of the constants
defined in the class, in the order they were defined.
N)r{ r� r| r r� r� r} s & r r � ValuesTests.test_iterconstants� sF � �
����2�2�4�5� � ���
�[�[�^�^�T�[�[� 2� 2� 3� � r c � � \ V P P 4 4 pV P V P P V^ , 4 V P V P P
V^, 4 R# )zq
The constants returned from L{Values.iterconstants} are identical to
the constants accessible using attributes.
N)r{ r� r| rJ r� r� r} s & r r� �/ValuesTests.test_attributeIterconstantsIdentity� sU � �
����2�2�4�5� � � � �T�[�[�^�^�Y�q�\�:� � � �T�[�[� 2� 2�I�a�L�Ar c � � \ V P P 4 4 p\ V P P 4 4 pV P V^ , V^ , 4 V P V^, V^, 4 R# )z`
The constants returned from L{Values.iterconstants} are identical on
each call to that method.
N)r{ r� r| rJ r� s & r r� �&ValuesTests.test_iterconstantsIdentity� sb � �
����2�2�4�5� ��T�[�[�.�.�0�1�� � � �U�1�X�y��|�4� � � �U�1�X�y��|�4r c �> � V P V P R4 R# )zW
L{Values._enumerants} is initialized once and its value re-used on
subsequent access.
r� N)rL r� r\ s &r r� � ValuesTests.test_initializedOnce� s � �
�!�!�$�+�+�t�4r )r� N)r r r r r9 r r] rb re r' rn rs r� r� r� r# rx r r� r� r� r r: r; s @r r� r� 6 sb �� � ��
�9�;�6�>�5�G�5�6�"J�4�=��B�5�5� 5r r� c �* a � ] tR tRt o RtR tRtV tR# )�_FlagsTestsMixini� z�
Mixin defining setup code for any tests for L{Flags} subclasses.
@ivar FXF: A L{Flags} subclass created for each test method.
c �0 � ! R R\ 4 pWn R# )z�
Create a fresh new L{Flags} subclass for each unit test to use. Since
L{Flags} is stateful, re-using the same subclass across test methods
makes exercising all of the implementation code paths difficult.
c �^ � ] tR tRt]! 4 t]! 4 t]! 4 t]! ^ 4 t]! 4 t Rt
R# )�#_FlagsTestsMixin.setUp.<locals>.FXFi� r N) r r r r r �READ�WRITE�APPEND� EXCLUSIVE�TEXTr r r r �FXFr� � s, � � �>�D� �N�E�!�^�F� %�T�*�I� �>�Dr r� N)r
r� )r r� s & r r �_FlagsTestsMixin.setUp� s � � "�%� "� �r )r� N)r r r r r9 r r r: r; s @r r� r� � s �� � ��
� r r� c �~ a � ] tR tRt o RtR tR tR tR tR t R t
R t R
t R t
R tR
tR tR tR tR tRtV tR# )�
FlagsTestsi� zu
Tests for L{constantly.Flags}, a base class for containers of
related, combinable flag or bitvector-like constants.
c �> � V P RV P 4 R# )zU
A subclass of L{Flags} raises L{TypeError} if an attempt is made to
instantiate it.
r� N)rE r� r\ s &r r] � FlagsTests.test_notInstantiable� s � �
�!�!�%����2r c �x � V P \ V P R4 4 V P \ V P R4 4 V P \ V P R4 4 V P \ V P R4 4 V P \ V P R4 4 R# )z�
Each name associated with a L{FlagConstant} instance in the definition
of a L{Flags} subclass is available as an attribute on the resulting
class.
r� r� r� r� r� N)r* ra r� r\ s &r rb �"FlagsTests.test_symbolicAttributes sw � �
�������&�1�2� �������'�2�3� �������(�3�4� �������+�6�7� �������&�1�2r c �P � V P \ V P R4 4 R# )z
As usual, names not defined in the class scope of a L{Flags} subclass
are not available as attributes on the resulting class.
r N)r+ ra r� r\ s &r re �&FlagsTests.test_withoutOtherAttributes s � �
�������5�1�2r c �d � V P R\ V P P 4 4 R# )z�
The string representation of a constant on a L{Flags} subclass includes
the name of the L{Flags} subclass and the name of the constant itself.
z
<FXF=READ>N)r r& r� r� r\ s &r r' � FlagsTests.test_representation s! � �
��� �t�D�H�H�M�M�':�;r c � � V P P R4 pV P V P P V4 R# )zA
Constants can be looked up by name using L{Flags.lookupByName}.
r� N)r� rk rJ r� �r �flags & r rn � FlagsTests.test_lookupByName! s0 � � �x�x�$�$�V�,�� � � �T�X�X�]�]�D�1r c � � V P \ V P P R4 V P \ V P P R4 V P \ V P P R4 R# )zd
Names not defined with a L{FlagConstant} instance cannot be looked up
using L{Flags.lookupByName}.
rk rq r N)r@ rr r� rk r\ s &r rs �&FlagsTests.test_notLookupMissingByName) sX � �
���*�d�h�h�&;�&;�^�L� ���*�d�h�h�&;�&;�Z�H� ���*�d�h�h�&;�&;�U�Cr c � � V P P ^4 pV P WP P 4 V P P ^4 pV P WP P 4 V P P ^4 pV P WP P
4 V P P ^ 4 pV P WP P 4 V P P ^@4 pV P WP P 4 R# )z�
Constants can be looked up by their associated value, defined
implicitly by the position in which the constant appears in the class
definition or explicitly by the argument passed to L{FlagConstant}.
N)r� r� rJ r� r� r� r� r� r� s & r r� � FlagsTests.test_lookupByValue3 s� � � �x�x�%�%�d�+�� � � �T�8�8�=�=�1��x�x�%�%�d�+�� � � �T�8�8�>�>�2��x�x�%�%�d�+�� � � �T�8�8�?�?�3��x�x�%�%�d�+�� � � �T�8�8�#5�#5�6��x�x�%�%�d�+�� � � �T�8�8�=�=�1r c �z � ! R R\ 4 pV P VP ^4 VP 4 R# )z�
If more than one constant is associated with a particular value,
L{Flags.lookupByValue} returns whichever of them is defined first.
c �6 � ] tR tRt]! ^4 t]! ^4 tRtR# )�5FlagsTests.test_lookupDuplicateByValue.<locals>.TIMEXiN r N)r r r r r �
ADJ_OFFSET�
MOD_OFFSETr r r r �TIMEXr� N s � �%�f�-�J� &�f�-�Jr r� N)r
rJ r� r� )r r� s & r r� �&FlagsTests.test_lookupDuplicateByValueI s1 � �
.�E� .�
� � �U� 0� 0�� 8�%�:J�:J�Kr c �\ � V P \ V P P ^4 R# )zl
L{Flags.lookupByValue} raises L{ValueError} when called with a value
with which no constant is associated.
N)r@ rr r� r� r\ s &r r� �'FlagsTests.test_notLookupMissingByValueX s � �
���*�d�h�h�&<�&<�d�Cr c �f � V P RV P P P 4 R# )r� r� N)r r� r� r! r\ s &r r# �FlagsTests.test_name` s" � �
������� � �!3�!3�4r c �z � V P V P P V P P 4 R# )z|
Repeated access of an attribute associated with a L{FlagConstant} value
in a L{Flags} subclass results in the same object.
N)rJ r� r� r\ s &r rx �!FlagsTests.test_attributeIdentityh s$ � �
� � �T�X�X�]�]�D�H�H�M�M�:r c �B � \ V P P 4 4 pV P V P P V P P
V P P V P P V P P .V4 R# )z|
L{Flags.iterconstants} returns an iterator over all of the constants
defined in the class, in the order they were defined.
N) r{ r� r| r r� r� r� r� r� r} s & r r � FlagsTests.test_iterconstantsp sg � �
����/�/�1�2� � ���
�X�X�]�]�D�H�H�N�N�D�H�H�O�O�
�X�X�
�
���� � �
0� � r c � � \ V P P 4 4 pV P V P P V^ , 4 V P V P P
V^, 4 V P V P P V^, 4 V P V P P V^, 4 V P V P P V^, 4 R# )zp
The constants returned from L{Flags.iterconstants} are identical to the
constants accessible using attributes.
N) r{ r� r| rJ r� r� r� r� r� r} s & r r� �.FlagsTests.test_attributeIterconstantsIdentity| s� � �
����/�/�1�2� � � � �T�X�X�]�]�I�a�L�9� � � �T�X�X�^�^�Y�q�\�:� � � �T�X�X�_�_�i��l�;� � � �T�X�X� /� /��1� �>� � � �T�X�X�]�]�I�a�L�9r c �� � \ V P P 4 4 p\ V P P 4 4 pV P V^ , V^ , 4 V P V^, V^, 4 V P V^, V^, 4 V P V^, V^, 4 V P V^, V^, 4 R# )z_
The constants returned from L{Flags.iterconstants} are identical on
each call to that method.
N)r{ r� r| rJ r� s & r r� �%FlagsTests.test_iterconstantsIdentity� s� � �
����/�/�1�2� ��T�X�X�+�+�-�.�� � � �U�1�X�y��|�4� � � �U�1�X�y��|�4� � � �U�1�X�y��|�4� � � �U�1�X�y��|�4� � � �U�1�X�y��|�4r c �> � V P V P R4 R# )zV
L{Flags._enumerants} is initialized once and its value re-used on
subsequent access.
r� N)rL r� r\ s &r r� � FlagsTests.test_initializedOnce� s � �
�!�!�$�(�(�F�3r r N)r r r r r9 r] rb re r' rn rs r� r� r� r# rx r r� r� r� r r: r; s @r r� r� � s] �� � ��3�
3�3�<�2�D�2�, L� D�5�;� �
:� 5� 4� 4r r� c �H a � ] tR tRt o RtR tR tR tR tR t R t
R t V t R
# ) �FlagConstantSimpleOrTestsi� z�
Tests for the C{|} operator as defined for L{FlagConstant} instances, used
to create new L{FlagConstant} instances representing both of two existing
L{FlagConstant} instances from the same L{Flags} class.
c �& � V P P V P P , pV P V P P P V P P P , VP 4 R# )z�
The value of the L{FlagConstant} which results from C{|} has all of the
bits set which were set in either of the values of the two original
constants.
N)r� r� r� r �valuer� s & r �
test_value�$FlagConstantSimpleOrTests.test_value� sV � � �x�x�}�}�t�x�x�~�~�-�� ��� �H�H�M�M� � �$�(�(�.�.�"6�"6� 6��
�
�
r c � � V P P V P P , pV P RVP 4 R# )z|
The name of the L{FlagConstant} instance which results from C{|}
includes the names of both of the two original constants.
z {READ,WRITE}N)r� r� r� r r! r� s & r r# �#FlagConstantSimpleOrTests.test_name� s2 � �
�x�x�}�}�t�x�x�~�~�-�� ��� ����3r c � � V P P V P P , pV P R\ V4 4 R# )z�
The string representation of a L{FlagConstant} instance which results
from C{|} includes the names of both of the two original constants.
z<FXF={READ,WRITE}>N)r� r� r� r r& r� s & r r' �-FlagConstantSimpleOrTests.test_representation� s3 � �
�x�x�}�}�t�x�x�~�~�-�� ���-�t�D�z�:r c �@ � V P \ V P P V P P , 4 \ R4 4 V P \ V P P 4 \ V P P 34 4 V P \ V P P V P P
, 4 \ V P P V P P
34 4 R# )zj
A L{FlagConstant} instance which results from C{|} can be
iterated upon to yield the original constants.
Nr )r �setr� r� r� r� r\ s &r � test_iterate�&FlagConstantSimpleOrTests.test_iterate� s� � �
��� ��������� � �.� /� ��G� �
��� ������ � ���� � �!� "� $�
��� ���������!3�!3�3� 4� ���� � ����!3�!3�4� 5� 7r c � � V P P V P P , pV P V P P V4 V P V P P
V4 R# )zR
A L{FlagConstant} instance which results from C{|} can be
tested for membership.
N)r� r� r� �assertIn� assertNotInr� )r �flagss & r �test_membership�)FlagConstantSimpleOrTests.test_membership� sN � �
��������!3�!3�3�� �
�
�d�h�h�n�n�e�,� ������ � ��.r c �P � V P V P P 4 V P V P P V P P , 4 V P V P P V P P , 4 R# )z0
Empty flags is false, non-empty flags is true.
N)r* r� r� r� r+ r\ s &r �test_truthiness�)FlagConstantSimpleOrTests.test_truthiness� s` � �
��������'� �����������);�);�;�<� ������ � �$�(�(�*<�*<�<�=r r N)
r r r r r9 r r# r' r r r! r r: r; s @r r
r
� s- �� � ��
�4�;�
7� /�>� >r r
c �6 a � ] tR tRt o RtR tR tR tRtV t R# )�FlagConstantSimpleAndTestsi� z�
Tests for the C{&} operator as defined for L{FlagConstant} instances, used
to create new L{FlagConstant} instances representing the common parts of
two existing L{FlagConstant} instances from the same L{Flags} class.
c �N � V P P V P P , pV P P V P P , pW, pV P V P P P
VP
4 R# )z�
The value of the L{FlagConstant} which results from C{&} has all of the
bits set which were set in both of the values of the two original
constants.
N�r� r� r� r� r r �r � readWrite� writeAppendr� s & r r �%FlagConstantSimpleAndTests.test_value� sb � � �X�X�]�]�T�X�X�^�^�3� ��x�x�~�~������7� ��&�� ������ � �-�-�t�z�z�:r c � � V P P V P P , pV P P V P P , pW, pV P RVP
4 R# )z�
The name of the L{FlagConstant} instance which results from C{&}
includes the names of only the flags which were set in both of the two
original constants.
r� N�r� r� r� r� r r! r' s & r r# �$FlagConstantSimpleAndTests.test_name� sT � � �X�X�]�]�T�X�X�^�^�3� ��x�x�~�~������7� ��&�� ����$�)�)�,r c � � V P P V P P , pV P P V P P , pW, pV P R\ V4 4 R# )z�
The string representation of a L{FlagConstant} instance which results
from C{&} includes the names of only the flags which were set in both
both of the two original constants.
z <FXF=WRITE>N�r� r� r� r� r r& r' s & r r' �.FlagConstantSimpleAndTests.test_representation sT � � �X�X�]�]�T�X�X�^�^�3� ��x�x�~�~������7� ��&�� ��� ��T�
�3r r N�
r r r r r9 r r# r' r r: r; s @r r$ r$ � s �� � ��
;� -� 4� 4r r$ c �6 a � ] tR tRt o RtR tR tR tRtV t R# )�"FlagConstantSimpleExclusiveOrTestsi z�
Tests for the C{^} operator as defined for L{FlagConstant} instances, used
to create new L{FlagConstant} instances representing the uncommon parts of
two existing L{FlagConstant} instances from the same L{Flags} class.
c � � V P P V P P , pV P P V P P , pW, pV P V P P P
V P P P
, VP
4 R# )z�
The value of the L{FlagConstant} which results from C{^} has all of the
bits set which were set in exactly one of the values of the two
original constants.
Nr& r' s & r r �-FlagConstantSimpleExclusiveOrTests.test_value sx � � �X�X�]�]�T�X�X�^�^�3� ��x�x�~�~������7� ��&�� ��� �H�H�M�M� � �$�(�(�/�/�"7�"7� 7����
r c � � V P P V P P , pV P P V P P , pW, pV P RVP
4 R# )z�
The name of the L{FlagConstant} instance which results from C{^}
includes the names of only the flags which were set in exactly one of
the two original constants.
z
{APPEND,READ}Nr, r' s & r r# �,FlagConstantSimpleExclusiveOrTests.test_name' sT � � �X�X�]�]�T�X�X�^�^�3� ��x�x�~�~������7� ��&�� ��� �$�)�)�4r c � � V P P V P P , pV P P V P P , pW, pV P R\ V4 4 R# )z�
The string representation of a L{FlagConstant} instance which results
from C{^} includes the names of only the flags which were set in
exactly one of the two original constants.
z<FXF={APPEND,READ}>Nr/ r' s & r r' �6FlagConstantSimpleExclusiveOrTests.test_representation3 sU � � �X�X�]�]�T�X�X�^�^�3� ��x�x�~�~������7� ��&�� ���.��T�
�;r r Nr1 r; s @r r3 r3 s �� � ��
� 5� <� <r r3 c �6 a � ] tR tRt o RtR tR tR tRtV t R# )�FlagConstantNegationTestsi@ z�
Tests for the C{~} operator as defined for L{FlagConstant} instances, used
to create new L{FlagConstant} instances representing all the flags from a
L{Flags} class not set in a particular L{FlagConstant} instance.
c � � V P P ( pV P V P P P V P P
P , V P P P , V P P P , VP 4 V P P ( pV P V P P P V P P
P , V P P P , V P P P , VP 4 R# )z
The value of the L{FlagConstant} which results from C{~} has all of the
bits set which were not set in the original constant.
N)r� r� r r� r r� r� r� r� s & r r �$FlagConstantNegationTests.test_valueF s � �
���
�
�~�� ��� �H�H�N�N� � � �H�H�O�O� !� !�
"� �H�H� � � $� $�
%�
�H�H�M�M� � �
�
�J�J� � ������� ��� �H�H�M�M� � � �H�H�O�O� !� !�
"� �H�H� � � $� $�
%�
�H�H�M�M� � �
�
�J�J� r c �l � V P P ( pV P RVP 4 R# )z�
The name of the L{FlagConstant} instance which results from C{~}
includes the names of all the flags which were not set in the original
constant.
z {APPEND,EXCLUSIVE,READ,TEXT}N)r� r� r r! r� s & r r# �#FlagConstantNegationTests.test_name\ s( � � ������� ���7����Cr c �j � V P P ( pV P R\ V4 4 R# )z�
The string representation of a L{FlagConstant} instance which results
from C{~} includes the names of all the flags which were not set in the
original constant.
z"<FXF={APPEND,EXCLUSIVE,READ,TEXT}>N)r� r� r r& r� s & r r' �-FlagConstantNegationTests.test_representationf s( � � ������� ���=�t�D�z�Jr r Nr1 r; s @r r; r; @ s! �� � ��
�,D�K� Kr r; c � a � ] tR tRt o RtR tR tR tR tR t R t
R t R
t R t
R tR
tR tR tR tR tR tR tR tR tR tRtV tR# )�OrderedConstantsTestsiq z�
Tests for the ordering of constants. All constants are ordered by
the order in which they are defined in their container class.
The ordering of constants that are not in the same container is not
defined.
c �f � V P \ P \ P 8 4 R# )zM
L{constantly.NamedConstant} preserves definition
order in C{<} comparisons.
N�r* � NamedLetters�alpha�betar\ s &r � test_orderedNameConstants_lt�2OrderedConstantsTests.test_orderedNameConstants_ltx s! � �
��� �*�*�\�->�->�>�?r c �� � V P \ P \ P 8* 4 V P \ P \ P 8* 4 R# )zN
L{constantly.NamedConstant} preserves definition
order in C{<=} comparisons.
NrE r\ s &r � test_orderedNameConstants_le�2OrderedConstantsTests.test_orderedNameConstants_le� s> � �
��� �*�*�l�.@�.@�@�A� ��� �*�*�l�.?�.?�?�@r c �f � V P \ P \ P 8� 4 R# )zM
L{constantly.NamedConstant} preserves definition
order in C{>} comparisons.
N)r* rF rH rG r\ s &r � test_orderedNameConstants_gt�2OrderedConstantsTests.test_orderedNameConstants_gt� s! � �
��� �)�)�L�,>�,>�>�?r c �� � V P \ P \ P 8� 4 V P \ P \ P 8� 4 R# )zN
L{constantly.NamedConstant} preserves definition
order in C{>=} comparisons.
NrE r\ s &r � test_orderedNameConstants_ge�2OrderedConstantsTests.test_orderedNameConstants_ge� s> � �
��� �*�*�l�.@�.@�@�A� ��� �)�)�\�-?�-?�?�@r c �� � V P \ P \ P 8 4 V P \ P \ P 8 4 R# )zM
L{constantly.ValueConstant} preserves definition
order in C{<} comparisons.
N�r* �
ValuedLettersrG �digamma�zetar\ s &r � test_orderedValueConstants_lt�3OrderedConstantsTests.test_orderedValueConstants_lt� s> � �
���
�+�+�m�.C�.C�C�D� ���
�-�-�
�0B�0B�B�Cr c �& � V P \ P \ P 8* 4 V P \ P \ P 8* 4 V P \ P \ P 8* 4 R# )zN
L{constantly.ValueConstant} preserves definition
order in C{<=} comparisons.
NrU r\ s &r � test_orderedValueConstants_le�3OrderedConstantsTests.test_orderedValueConstants_le� s[ � �
���
�+�+�}�/B�/B�B�C� ���
�+�+�}�/D�/D�D�E� ���
�-�-� �1C�1C�C�Dr c �� � V P \ P \ P 8� 4 V P \ P \ P 8� 4 R# )zM
L{constantly.ValueConstant} preserves definition
order in C{>} comparisons.
N)r* rV rW rG rX r\ s &r � test_orderedValueConstants_gt�3OrderedConstantsTests.test_orderedValueConstants_gt� s> � �
���
�-�-�
�0C�0C�C�D� ���
�*�*�]�-B�-B�B�Cr c �& � V P \ P \ P 8� 4 V P \ P \ P 8� 4 V P \ P \ P 8� 4 R# )zN
L{constantly.ValueConstant} preserves definition
order in C{>=} comparisons.
NrU r\ s &r � test_orderedValueConstants_ge�3OrderedConstantsTests.test_orderedValueConstants_ge� s[ � �
���
�+�+�}�/B�/B�B�C� ���
�-�-� �1D�1D�D�E� ���
�*�*�m�.C�.C�C�Dr c �� � V P \ P \ P 8 4 V P \ P \ P 8 4 R# )zL
L{constantly.FlagConstant} preserves definition
order in C{<} comparisons.
N�r* �
PizzaToppings�
mozzarella�pesto� pepperonir\ s &r � test_orderedFlagConstants_lt�2OrderedConstantsTests.test_orderedFlagConstants_lt� s> � �
���
�0�0�=�3F�3F�F�G� ���
�+�+�m�.E�.E�E�Fr c �& � V P \ P \ P 8* 4 V P \ P \ P 8* 4 V P \ P \ P 8* 4 R# )zM
L{constantly.FlagConstant} preserves definition
order in C{<=} comparisons.
Nre r\ s &r � test_orderedFlagConstants_le�2OrderedConstantsTests.test_orderedFlagConstants_le� s[ � �
���
�0�0�M�4L�4L�L�M� ���
�0�0�M�4G�4G�G�H� ���
�+�+�}�/F�/F�F�Gr c �� � V P \ P \ P 8� 4 V P \ P \ P 8� 4 R# )zL
L{constantly.FlagConstant} preserves definition
order in C{>} comparisons.
N)r* rf rh rg ri r\ s &r � test_orderedFlagConstants_gt�2OrderedConstantsTests.test_orderedFlagConstants_gt� s> � �
���
�+�+�m�.F�.F�F�G� ���
�/�/�-�2E�2E�E�Fr c �& � V P \ P \ P 8� 4 V P \ P \ P 8� 4 V P \ P \ P 8� 4 R# )zM
L{constantly.FlagConstant} preserves definition
order in C{>=} comparisons.
Nre r\ s &r � test_orderedFlagConstants_ge�2OrderedConstantsTests.test_orderedFlagConstants_ge� s[ � �
���
�0�0�M�4L�4L�L�M� ���
�+�+�}�/G�/G�G�H� ���
�/�/�=�3F�3F�F�Gr c � � V P \ \ P P \
P 4 4 R# )zr
L{constantly._constants._Constant.__lt__} returns C{NotImplemented}
when comparing constants of different types.
N)� assertEquals�NotImplementedrF rG �__lt__rV r\ s &r �!test_orderedDifferentConstants_lt�7OrderedConstantsTests.test_orderedDifferentConstants_lt� �/ � �
��� � � � � %� %�m�&9�&9� :�
r c � � V P \ \ P P \
P 4 4 R# )zr
L{constantly._constants._Constant.__le__} returns C{NotImplemented}
when comparing constants of different types.
N)rv rw rF rG �__le__rV r\ s &r �!test_orderedDifferentConstants_le�7OrderedConstantsTests.test_orderedDifferentConstants_le� r{ r c � � V P \ \ P P \
P 4 4 R# )zr
L{constantly._constants._Constant.__gt__} returns C{NotImplemented}
when comparing constants of different types.
N)rv rw rF rG �__gt__rV r\ s &r �!test_orderedDifferentConstants_gt�7OrderedConstantsTests.test_orderedDifferentConstants_gt� r{ r c � � V P \ \ P P \
P 4 4 R# )zr
L{constantly._constants._Constant.__ge__} returns C{NotImplemented}
when comparing constants of different types.
N)rv rw rF rG �__ge__rV r\ s &r �!test_orderedDifferentConstants_ge�7OrderedConstantsTests.test_orderedDifferentConstants_ge r{ r c � � V P \ \ P P \
P 4 4 R# )z�
L{constantly._constants._Constant.__lt__} returns C{NotImplemented}
when comparing constants belonging to different containers.
N)rv rw rF rG rx �MoreNamedLettersrW r\ s &r �"test_orderedDifferentContainers_lt�8OrderedConstantsTests.test_orderedDifferentContainers_lt �0 � �
��� � � � � %� %�&6�&>�&>� ?�
r c � � V P \ \ P P \
P 4 4 R# )z�
L{constantly._constants._Constant.__le__} returns C{NotImplemented}
when comparing constants belonging to different containers.
N)rv rw rF rG r} r� rW r\ s &r �"test_orderedDifferentContainers_le�8OrderedConstantsTests.test_orderedDifferentContainers_le r� r c � � V P \ \ P P \
P 4 4 R# )z�
L{constantly._constants._Constant.__gt__} returns C{NotImplemented}
when comparing constants belonging to different containers.
N)rv rw rF rG r� r� rW r\ s &r �"test_orderedDifferentContainers_gt�8OrderedConstantsTests.test_orderedDifferentContainers_gt( r� r c � � V P \ \ P P \
P 4 4 R# )z�
L{constantly._constants._Constant.__ge__} returns C{NotImplemented}
when comparing constants belonging to different containers.
N)rv rw rF rG r� r� rW r\ s &r �"test_orderedDifferentContainers_ge�8OrderedConstantsTests.test_orderedDifferentContainers_ge3 r� r r N)r r r r r9 rI rL rO rR rY r\ r_ rb rj rm rp rs ry r~ r� r� r� r� r� r� r r: r; s @r rC rC q s �� � �� @�A�@�A�D�E�D�E�G�H�G�H�
�
�
�
�
�
�
�
�
r rC c �6 � ] tR tRtRt]! 4 t]! 4 tRtR# )rF i? z
Some letters, named.
r N) r r r r r9 r rG rH r r r r rF rF ? s � ��
�O�E� �O�Dr rF c �6 � ] tR tRtRt]! 4 t]! 4 tRtR# )r� iH z
Some more letters, named.
r N) r r r r r9 r rW rX r r r r r� r� H s � �� �o�G� �O�Dr r� c �J � ] tR tRtRt]! R4 t]! R4 t]! R4 tRt R# )rV iQ z7
Some more letters, with cooresponding unicode values.
u Αu Ϝu Ζr N)
r r r r r9 r rG rW rX r r r r rV rV Q s' � �� �I�&�E��I�&�G��I�&�Dr rV c �J � ] tR tRtRt]! ^4 t]! ^4 t]! ^4 tRt R# )rf i_ z@
Some pizza toppings, with obviously meaningful bitwise values.
r N)
r r r r r9 r rg rh ri r r r r rf rf _ s' � �� �f�%�J� �f�%�E� �f�%�Ir rf N) r9 �
__future__r r �twisted.trial.unittestr �
constantlyr r r r r r
r rW r> rO r� r� r� r
r$ r3 r; rC rF r� rV rf r r r �<module>r� s ��� 1� +�� � C7�� C7�N",�6� ",�Ls��/� s�n`5�(� 0� `5�H�v� �:e4�!�8�-A� e4�RD>� 0�(� D>�P'4�!1�8� '4�V)<�)9�8� )<�Z-K� 0�(� -K�bJ
�H� J
�\ �5� � �u� �
'�F�
'� &�E� &r