hSrSSKJrJr SSKJr SSKJrJrJ r J r J r J r "SS\5r "SS\5r"S S \\5r"S S \\5r"S S\5r"SS\\\5r"SS\\5r"SS\\5r"SS\\5r"SS\\5r"SS\5r"SS\5r"SS\5r"SS \ 5r"S!S"\ 5rg#)$z Unit tests for L{constantly}. )divisionabsolute_import)TestCase) NamedConstantNames ValueConstantValues FlagConstantFlagsc<\rSrSrSrSrSrSrSrSr Sr S r g ) NamedConstantTestsz_ Tests for the L{constantly.NamedConstant} class which is used to represent individual values. c."SS[5nXlg)z> Create a dummy container into which constants can be placed. c\rSrSrSrg)%NamedConstantTests.setUp..fooN)__name__ __module__ __qualname____firstlineno____static_attributes__re/root/1688_scrapy/alibaba-scraper/venv/lib/python3.13/site-packages/constantly/test/test_constants.pyfoors rrN)r container)selfrs rsetUpNamedConstantTests.setUps % rc[5nURURSS5 URSUR5 g)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 assertEqualnamerr$s r test_nameNamedConstantTests.test_name s3  dnneT2  *rc[5nURURSS5 URS[ U55 g)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 )rr"rr#reprr%s rtest_representation&NamedConstantTests.test_representation*s3  dnneT2 d4j1rc[5nURURSS5 URX:H5 UR X:g5 g)z7 A L{NamedConstant} instance compares equal to itself. r!N)rr"r assertTrue assertFalser%s r test_equality NamedConstantTests.test_equality4s= dnneT2  % &rc[5nURURSS5 [5nURURSS5 URX:H5 UR X:g5 g)zN Two different L{NamedConstant} instances do not compare equal to each other. r!N)rr"rr.r-rfirstseconds rtest_nonequality#NamedConstantTests.test_nonequality>sX  t~~ud3t4 ) (rc[5nURURSS5 [5nURURSS5 UR[ U5[ U55 g)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)rr"rassertNotEqualhashr2s r test_hashNamedConstantTests.test_hashKsR  t~~ud3t4 DKf6r)rN) rrrr__doc__rr&r*r/r5r:rrrrr r s%+2' ) 7rr c$\rSrSrSrSrSrSrg)_ConstantsTestsMixinYzP Mixin defining test helpers common to multiple types of constants collections. clUR[U5nURUS-[U55 g)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)rr$clsexcs r_notInstantiableTest)_ConstantsTestsMixin._notInstantiableTest^s0 3/  ;;SXFrclURn[X5 URnURX45 g)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) _enumerantsgetattrassertIdentical)rr constantNamer3r4s r_initializedOnceTest)_ConstantsTestsMixin._initializedOnceTestjs2%%  (&& U+rrN)rrrrr<rFrMrrrrr>r>Ys G,rr>cx\rSrSrSrSrSrSrSrSr Sr S r S r S r S rS rSrSrSrSrSrSrg) NamesTestszS Tests for L{constantly.Names}, a base class for containers of related constaints. c."SS[5nXlg)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^\rSrSrSr\"5r\"5r\"5r\"5r \ "5r Sr g) NamesTests.setUp..METHODzI A container for some named constants to use in unit tests for L{Names}. rN) rrrrr<rGETPUTPOSTDELETEobjectextrarrrrMETHODrTs,  /C/C ?D"_FHErr\N)rr\)rr\s rrNamesTests.setUps U  rc<URSUR5 g)zU A subclass of L{Names} raises C{TypeError} if an attempt is made to instantiate it. r\N)rFr\rs rtest_notInstantiableNamesTests.test_notInstantiable !!(DKK8rc,UR[URS55 UR[URS55 UR[URS55 UR[URS55 g)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. rVrWrXrYN)r-hasattrr\r_s rtest_symbolicAttributes"NamesTests.test_symbolicAttributess`  U34  U34  V45  X67rcNUR[URS55 g)z As usual, names not defined in the class scope of a L{Names} subclass are not available as attributes on the resulting class. rN)r.rdr\r_s rtest_withoutOtherAttributes&NamesTests.test_withoutOtherAttributes e45rcbURS[URR55 g)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 N)r#r)r\rVr_s rr*NamesTests.test_representations! dkkoo)>?rcURRS5nURURRU5 g)zA Constants can be looked up by name using L{Names.lookupByName}. rVN)r\ lookupByNamerKrVrmethods rtest_lookupByNameNamesTests.test_lookupByNames0))%0 T[[__f5rc\UR[URRS5 UR[URRS5 UR[URRS5 UR[URRS5 g)ze Names not defined with a L{NamedConstant} instance cannot be looked up using L{Names.lookupByName}. rn__init__rr[N)rA ValueErrorr\rnr_s rtest_notLookupMissingByName&NamesTests.test_notLookupMissingByNamest *dkk&>&>O *dkk&>&> K *dkk&>&>F *dkk&>&>HrcdURSURRR5 g)zQ The C{name} attribute of one of the named constants gives that constant's name. rVN)r#r\rVr$r_s rr&NamesTests.test_names"   4 45rcxURURRURR5 g)z} Repeated access of an attribute associated with a L{NamedConstant} value in a L{Names} subclass results in the same object. N)rKr\rVr_s rtest_attributeIdentity!NamesTests.test_attributeIdentitys$ T[[__dkkoo>rc[URR55nURURRURR URR URR/U5 g)z| L{Names.iterconstants} returns an iterator over all of the constants defined in the class, in the order they were defined. N)listr\ iterconstantsr#rVrWrXrYr constantss rtest_iterconstantsNamesTests.test_iterconstantss_ 2245   [[__dkkoo [[  t{{11 3  rc[URR55nURURRUS5 URURR US5 URURR US5 URURRUS5 g)zp The constants returned from L{Names.iterconstants} are identical to the constants accessible using attributes. rN)r~r\rrKrVrWrXrYrs r#test_attributeIterconstantsIdentity.NamesTests.test_attributeIterconstantsIdentitys 2245  T[[__il; T[[__il; T[[--y|< T[[//1>rcP[URR55n[URR55nURUSUS5 URUSUS5 URUSUS5 URUSUS5 g)z_ The constants returned from L{Names.iterconstants} are identical on each call to that method. rrrrN)r~r\rrKrragains rtest_iterconstantsIdentity%NamesTests.test_iterconstantsIdentitys 2245 T[[..01 U1Xy|4 U1Xy|4 U1Xy|4 U1Xy|4rc<URURS5 g)zV L{Names._enumerants} is initialized once and its value re-used on subsequent access. rVN)rMr\r_s rtest_initializedOnceNamesTests.test_initializedOnces !!$++u5rc^"U4SjS[5nTRTRRUR5 g)z A constant defined on a L{Names} subclass may be set as an attribute of another class and then retrieved using that attribute. cD>\rSrSrYRR rSrg)8NamesTests.test_asForeignClassAttribute..AnotherirNrrrrr\rV somethingrr_srAnotherr IrrNrZrKr\rVrrrs` rtest_asForeignClassAttribute'NamesTests.test_asForeignClassAttribute s/  (f ( T[[__g.?.?@rc^"U4SjS[5nTRTRRU"5R5 g)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. cD>\rSrSrYRR rSrg)CNamesTests.test_asForeignClassAttributeViaInstance..AnotherirNrr_srrrrrrNrrs` r'test_asForeignClassAttributeViaInstance2NamesTests.test_asForeignClassAttributeViaInstances1  (f ( T[[__gi.A.ABrct^U4SjnTR[U5nTRS[U55 g)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*>"U4SjS[5ng)NcD>\rSrSrYRR rSrg)XNamesTests.test_notAsAlternateContainerAttribute..defineIt..AnotherNamesi+rNrr_sr AnotherNamesr+s KKOO rr)r)rrs rdefineItBNamesTests.test_notAsAlternateContainerAttribute..defineIt*s ,u ,rzDCannot use as the value of an attribute on AnotherNamesN)rArur#rC)rrrEs` r%test_notAsAlternateContainerAttribute0NamesTests.test_notAsAlternateContainerAttribute$s6  , H5   H r)r\N)rrrrr<rr`rerhr*rqrvr&r{rrrrrrrrrrrrPrPs[*9 86@6I6?  ? 56A CrrPcx\rSrSrSrSrSrSrSrSr Sr S r S r S r S rS rSrSrSrSrSrSrg) ValuesTestsi6zi Tests for L{constantly.Names}, a base class for containers of related constaints with arbitrary values. c."SS[5nXlg)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. c4\rSrSr\"S5r\"S5rSrg)!ValuesTests.setUp..STATUSiA200404rN)rrrrrOK NOT_FOUNDrrrrSTATUSrAsu%B%e,IrrN)r r)rrs rrValuesTests.setUp;s  -V - rc<URSUR5 g)zV A subclass of L{Values} raises C{TypeError} if an attempt is made to instantiate it. rN)rFrr_s rr` ValuesTests.test_notInstantiableHrbrcUR[URS55 UR[URS55 g)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. rrN)r-rdrr_s rre#ValuesTests.test_symbolicAttributesPs2  T23  [9:rcNUR[URS55 g)z As usual, names not defined in the class scope of a L{Values} subclass are not available as attributes on the resulting class. rN)r.rdrr_s rrh'ValuesTests.test_withoutOtherAttributesZrjrcbURS[URR55 g)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 N)r#r)rrr_s rr*ValuesTests.test_representationbs! T[[^^(<=rcURRS5nURURRU5 g)zB Constants can be looked up by name using L{Values.lookupByName}. rN)rrnrKrros rrqValuesTests.test_lookupByNameks0))$/ T[[^^V4rcUR[URRS5 UR[URRS5 UR[URRS5 g)zf Names not defined with a L{ValueConstant} instance cannot be looked up using L{Values.lookupByName}. rnrtrN)rArurrnr_s rrv'ValuesTests.test_notLookupMissingByNamessX *dkk&>&>O *dkk&>&> K *dkk&>&>FrcURRS5nURURRU5 g)z Constants can be looked up by their associated value, defined by the argument passed to L{ValueConstant}, using L{Values.lookupByValue}. rN)r lookupByValuerKr)rstatuss rtest_lookupByValueValuesTests.test_lookupByValue}s0 **51 T[[^^V4rcx"SS[5nURURS5UR5 g)z If more than one constant is associated with a particular value, L{Values.lookupByValue} returns whichever of them is defined first. c8\rSrSrSr\"S5r\"S5rSrg)BValuesTests.test_lookupDuplicateByValue..TRANSPORT_MESSAGEiz. Message types supported by an SSH transport. rN) rrrrr<rKEX_DH_GEX_REQUEST_OLD KEXDH_INITrrrrTRANSPORT_MESSAGErs &32%6 "&r*JrrrN)r rKrr)rrs rtest_lookupDuplicateByValue'ValuesTests.test_lookupDuplicateByValues5  + +   + +B /  4 4 6rcUR[URRS5 UR[URRS5 UR[URRS5 g)zm L{Values.lookupByValue} raises L{ValueError} when called with a value with which no constant is associated. rz200.1N)rArurrr_s rtest_notLookupMissingByValue(ValuesTests.test_notLookupMissingByValuesX *dkk&?&?F *dkk&?&?E *dkk&?&?IrcdURSURRR5 g)K The C{name} attribute of one of the constants gives that constant's name. rN)r#rrr$r_s rr&ValuesTests.test_names" t{{~~223rcxURURRURR5 g)z~ Repeated access of an attribute associated with a L{ValueConstant} value in a L{Values} subclass results in the same object. N)rKrrr_s rr{"ValuesTests.test_attributeIdentitys$ T[[^^T[[^^5G56"J4=B55rrc\rSrSrSrSrSrg)_FlagsTestsMixiniz Mixin defining setup code for any tests for L{Flags} subclasses. @ivar FXF: A L{Flags} subclass created for each test method. c."SS[5nXlg)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\\rSrSr\"5r\"5r\"5r\"S5r\"5r Sr g)#_FlagsTestsMixin.setUp..FXFi rN) rrrrr READWRITEAPPEND EXCLUSIVETEXTrrrrFXFrs,>D NE!^F%T*I >DrrN)r r)rrs rr_FlagsTestsMixin.setUps "% "r)rN)rrrrr<rrrrrrrs  rrcr\rSrSrSrSrSrSrSrSr Sr S r S r S r S rS rSrSrSrSrSrg) FlagsTestsizu Tests for L{constantly.Flags}, a base class for containers of related, combinable flag or bitvector-like constants. c<URSUR5 g)zU A subclass of L{Flags} raises L{TypeError} if an attempt is made to instantiate it. rN)rFrr_s rr`FlagsTests.test_notInstantiables !!%2rcvUR[URS55 UR[URS55 UR[URS55 UR[URS55 UR[URS55 g)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. rrrrrN)r-rdrr_s rre"FlagsTests.test_symbolicAttributessw &12 '23 (34 +67 &12rcNUR[URS55 g)z As usual, names not defined in the class scope of a L{Flags} subclass are not available as attributes on the resulting class. rN)r.rdrr_s rrh&FlagsTests.test_withoutOtherAttributess 512rcbURS[URR55 g)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 N)r#r)rrr_s rr*FlagsTests.test_representations! tDHHMM':;rcURRS5nURURRU5 g)zA Constants can be looked up by name using L{Flags.lookupByName}. rN)rrnrKrrflags rrqFlagsTests.test_lookupByName!s0xx$$V, TXX]]D1rcUR[URRS5 UR[URRS5 UR[URRS5 g)zd Names not defined with a L{FlagConstant} instance cannot be looked up using L{Flags.lookupByName}. rnrtrN)rArurrnr_s rrv&FlagsTests.test_notLookupMissingByName)sX *dhh&;&;^L *dhh&;&;ZH *dhh&;&;UCrcURRS5nURXRR5 URRS5nURXRR5 URRS5nURXRR 5 URRS5nURXRR 5 URRS5nURXRR5 g)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}. rrr@N)rrrKrrrrrrs rrFlagsTests.test_lookupByValue3s xx%%d+ T88==1xx%%d+ T88>>2xx%%d+ T88??3xx%%d+ T88#5#56xx%%d+ T88==1rcx"SS[5nURURS5UR5 g)z If more than one constant is associated with a particular value, L{Flags.lookupByValue} returns whichever of them is defined first. c4\rSrSr\"S5r\"S5rSrg)5FlagsTests.test_lookupDuplicateByValue..TIMEXiNrrN)rrrrr ADJ_OFFSET MOD_OFFSETrrrrTIMEXrNs%f-J&f-JrrrN)r rKrr)rrs rr&FlagsTests.test_lookupDuplicateByValueIs1  .E . U008%:J:JKrcZUR[URRS5 g)zl L{Flags.lookupByValue} raises L{ValueError} when called with a value with which no constant is associated. N)rArurrr_s rr'FlagsTests.test_notLookupMissingByValueXs *dhh&<& TXX]]IaL9rc[URR55n[URR55nURUSUS5 URUSUS5 URUSUS5 URUSUS5 URUSUS5 g)z_ The constants returned from L{Flags.iterconstants} are identical on each call to that method. rrrrrN)r~rrrKrs rr%FlagsTests.test_iterconstantsIdentitys //12 TXX++-. U1Xy|4 U1Xy|4 U1Xy|4 U1Xy|4 U1Xy|4rc<URURS5 g)zV L{Flags._enumerants} is initialized once and its value re-used on subsequent access. rN)rMrr_s rrFlagsTests.test_initializedOnces !!$((F3rrN)rrrrr<r`rerhr*rqrvrrrr&r{rrrrrrrrrrsU3 33<2D2, LD5;  : 54rrc<\rSrSrSrSrSrSrSrSr Sr S r g ) FlagConstantSimpleOrTestsiz 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. cURRURR-nURURRRURRR-UR5 g)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)rrrr#valuers r test_value$FlagConstantSimpleOrTests.test_valuesV xx}}txx~~-  HHMM  $((.."6"6 6  rcURRURR-nURSUR5 g)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)rrrr#r$rs rr&#FlagConstantSimpleOrTests.test_names2 xx}}txx~~- 3rcURRURR-nURS[ U55 g)z The string representation of a L{FlagConstant} instance which results from C{|} includes the names of both of the two original constants. zN)rrrr#r)rs rr*-FlagConstantSimpleOrTests.test_representations3 xx}}txx~~- -tDz:rc.UR[URRURR-5[S55 UR[URR5[URR455 UR[URRURR -5[URRURR 455 g)zj A L{FlagConstant} instance which results from C{|} can be iterated upon to yield the original constants. rN)r#setrrrrr_s r test_iterate&FlagConstantSimpleOrTests.test_iterates  . / G     ! " $  !3!33 4 !3!34 5 7rcURRURR-nURURRU5 UR URR U5 g)zR A L{FlagConstant} instance which results from C{|} can be tested for membership. N)rrrassertIn assertNotInr)rflagss rtest_membership)FlagConstantSimpleOrTests.test_membershipsN !3!33 dhhnne, .rc>URURR5 URURRURR-5 UR URRURR-5 g)z0 Empty flags is false, non-empty flags is true. N)r-rrrr.r_s rtest_truthiness)FlagConstantSimpleOrTests.test_truthinesss` ' ););;< $((*<*<<=rrN) rrrrr<rr&r*r$r*r-rrrrrrs%  4; 7 />rrc*\rSrSrSrSrSrSrSrg)FlagConstantSimpleAndTestsiz 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. c4URRURR-nURRURR-nX-nUR URRR UR 5 g)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. Nrrrrr#rr readWrite writeAppendrs rr%FlagConstantSimpleAndTests.test_valuesb XX]]TXX^^3 xx~~7 & --tzz:rcURRURR-nURRURR-nX-nUR SUR 5 g)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. rNrrrrr#r$r3s rr&$FlagConstantSimpleAndTests.test_namesT XX]]TXX^^3 xx~~7 & $)),rcURRURR-nURRURR-nX-nUR S[ U55 g)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 Nrrrrr#r)r3s rr*.FlagConstantSimpleAndTests.test_representationsT XX]]TXX^^3 xx~~7 & T 3rrN rrrrr<rr&r*rrrrr0r0s ; - 4rr0c*\rSrSrSrSrSrSrSrg)"FlagConstantSimpleExclusiveOrTestsiz 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. cvURRURR-nURRURR-nX- nUR URRR URRR -UR 5 g)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. Nr2r3s rr-FlagConstantSimpleExclusiveOrTests.test_valuesx XX]]TXX^^3 xx~~7 &  HHMM  $((//"7"7 7 rcURRURR-nURRURR-nX- nUR SUR 5 g)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}Nr8r3s rr&,FlagConstantSimpleExclusiveOrTests.test_name'sT XX]]TXX^^3 xx~~7 & $))4rcURRURR-nURRURR-nX- nUR S[ U55 g)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. zNr;r3s rr*6FlagConstantSimpleExclusiveOrTests.test_representation3sU XX]]TXX^^3 xx~~7 & .T ;rrNr=rrrr?r?s   5 N)rrr#r)rs rr*-FlagConstantNegationTests.test_representationfs(  =tDzJrrNr=rrrrGrG@s ,DKrrGc\rSrSrSrSrSrSrSrSr Sr S r S r S r S rS rSrSrSrSrSrSrSrSrSrSrg)OrderedConstantsTestsiqz 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. cdUR[R[R:5 g)zM L{constantly.NamedConstant} preserves definition order in C{<} comparisons. Nr- NamedLettersalphabetar_s rtest_orderedNameConstants_lt2OrderedConstantsTests.test_orderedNameConstants_ltxs!  **\->->>?rcUR[R[R:*5 UR[R[R:*5 g)zN L{constantly.NamedConstant} preserves definition order in C{<=} comparisons. NrQr_s rtest_orderedNameConstants_le2OrderedConstantsTests.test_orderedNameConstants_les>  **l.@.@@A  **l.?.??@rcdUR[R[R:5 g)zM L{constantly.NamedConstant} preserves definition order in C{>} comparisons. N)r-rRrTrSr_s rtest_orderedNameConstants_gt2OrderedConstantsTests.test_orderedNameConstants_gts!  ))L,>,>>?rcUR[R[R:5 UR[R[R:5 g)zN L{constantly.NamedConstant} preserves definition order in C{>=} comparisons. NrQr_s rtest_orderedNameConstants_ge2OrderedConstantsTests.test_orderedNameConstants_ges>  **l.@.@@A  ))\-?-??@rcUR[R[R:5 UR[R[R:5 g)zM L{constantly.ValueConstant} preserves definition order in C{<} comparisons. Nr- ValuedLettersrSdigammazetar_s rtest_orderedValueConstants_lt3OrderedConstantsTests.test_orderedValueConstants_lts>  ++m.C.CCD  -- 0B0BBCrc$UR[R[R:*5 UR[R[R:*5 UR[R[R:*5 g)zN L{constantly.ValueConstant} preserves definition order in C{<=} comparisons. Nrar_s rtest_orderedValueConstants_le3OrderedConstantsTests.test_orderedValueConstants_les[  ++}/B/BBC  ++}/D/DDE  --1C1CCDrcUR[R[R:5 UR[R[R:5 g)zM L{constantly.ValueConstant} preserves definition order in C{>} comparisons. N)r-rbrcrSrdr_s rtest_orderedValueConstants_gt3OrderedConstantsTests.test_orderedValueConstants_gts>  -- 0C0CCD  **]-B-BBCrc$UR[R[R:5 UR[R[R:5 UR[R[R:5 g)zN L{constantly.ValueConstant} preserves definition order in C{>=} comparisons. Nrar_s rtest_orderedValueConstants_ge3OrderedConstantsTests.test_orderedValueConstants_ges[  ++}/B/BBC  --1D1DDE  **m.C.CCDrcUR[R[R:5 UR[R[R:5 g)zL L{constantly.FlagConstant} preserves definition order in C{<} comparisons. Nr- PizzaToppings mozzarellapesto pepperonir_s rtest_orderedFlagConstants_lt2OrderedConstantsTests.test_orderedFlagConstants_lts>  00=3F3FFG  ++m.E.EEFrc$UR[R[R:*5 UR[R[R:*5 UR[R[R:*5 g)zM L{constantly.FlagConstant} preserves definition order in C{<=} comparisons. Nrqr_s rtest_orderedFlagConstants_le2OrderedConstantsTests.test_orderedFlagConstants_les[  00M4L4LLM  00M4G4GGH  ++}/F/FFGrcUR[R[R:5 UR[R[R:5 g)zL L{constantly.FlagConstant} preserves definition order in C{>} comparisons. N)r-rrrtrsrur_s rtest_orderedFlagConstants_gt2OrderedConstantsTests.test_orderedFlagConstants_gts>  ++m.F.FFG  //-2E2EEFrc$UR[R[R:5 UR[R[R:5 UR[R[R:5 g)zM L{constantly.FlagConstant} preserves definition order in C{>=} comparisons. Nrqr_s rtest_orderedFlagConstants_ge2OrderedConstantsTests.test_orderedFlagConstants_ges[  00M4L4LLM  ++}/G/GGH  //=3F3FFGrcUR[[RR [ R55 g)zr L{constantly._constants._Constant.__lt__} returns C{NotImplemented} when comparing constants of different types. N) assertEqualsNotImplementedrRrS__lt__rbr_s r!test_orderedDifferentConstants_lt7OrderedConstantsTests.test_orderedDifferentConstants_lt/      % %m&9&9 : rcUR[[RR [ R55 g)zr L{constantly._constants._Constant.__le__} returns C{NotImplemented} when comparing constants of different types. N)rrrRrS__le__rbr_s r!test_orderedDifferentConstants_le7OrderedConstantsTests.test_orderedDifferentConstants_lerrcUR[[RR [ R55 g)zr L{constantly._constants._Constant.__gt__} returns C{NotImplemented} when comparing constants of different types. N)rrrRrS__gt__rbr_s r!test_orderedDifferentConstants_gt7OrderedConstantsTests.test_orderedDifferentConstants_gtrrcUR[[RR [ R55 g)zr L{constantly._constants._Constant.__ge__} returns C{NotImplemented} when comparing constants of different types. N)rrrRrS__ge__rbr_s r!test_orderedDifferentConstants_ge7OrderedConstantsTests.test_orderedDifferentConstants_gerrcUR[[RR [ R 55 g)z L{constantly._constants._Constant.__lt__} returns C{NotImplemented} when comparing constants belonging to different containers. N)rrrRrSrMoreNamedLettersrcr_s r"test_orderedDifferentContainers_lt8OrderedConstantsTests.test_orderedDifferentContainers_lt0      % %&6&>&> ? rcUR[[RR [ R 55 g)z L{constantly._constants._Constant.__le__} returns C{NotImplemented} when comparing constants belonging to different containers. N)rrrRrSrrrcr_s r"test_orderedDifferentContainers_le8OrderedConstantsTests.test_orderedDifferentContainers_lerrcUR[[RR [ R 55 g)z L{constantly._constants._Constant.__gt__} returns C{NotImplemented} when comparing constants belonging to different containers. N)rrrRrSrrrcr_s r"test_orderedDifferentContainers_gt8OrderedConstantsTests.test_orderedDifferentContainers_gt(rrcUR[[RR [ R 55 g)z L{constantly._constants._Constant.__ge__} returns C{NotImplemented} when comparing constants belonging to different containers. N)rrrRrSrrrcr_s r"test_orderedDifferentContainers_ge8OrderedConstantsTests.test_orderedDifferentContainers_ge3rrrN)rrrrr<rUrXr[r^rerhrkrnrvryr|rrrrrrrrrrrrrrOrOqsw @A@ADEDEGHGH        rrOc4\rSrSrSr\"5r\"5rSrg)rRi?z Some letters, named. rN) rrrrr<rrSrTrrrrrRrR?s OE ODrrRc4\rSrSrSr\"5r\"5rSrg)riHz Some more letters, named. rN) rrrrr<rrcrdrrrrrrHsoG ODrrcH\rSrSrSr\"S5r\"S5r\"S5rSr g)rbiQz7 Some more letters, with cooresponding unicode values. uΑuϜuΖrN) rrrrr<rrSrcrdrrrrrbrbQs'I&EI&GI&DrrbcH\rSrSrSr\"S5r\"S5r\"S5rSr g)rri_z@ Some pizza toppings, with obviously meaningful bitwise values. rr rrN) rrrrr<r rsrtrurrrrrrrr_s' f%Jf%Ef%IrrrN)r< __future__rrtwisted.trial.unittestr constantlyrrrr r r r rZr>rPrrrrr0r?rGrOrRrrbrrrrrrs1+ C7C7N",6",Ls/sn`5(0`5Hv:e4!8-Ae4RD> 0(D>P'4!18'4V)<)98)