&hxSSKJr SSKrSSKrSSKrSSKrSSKrSSKrSSK7 SSK J r S\R"5:Hr SSjr S SjrSrS rS rS rS!S jrS rS!Sjr"SS\R,5r"SS\R0R25r"SS\5r"SS\5r"SS\5r"SS\R,5r\R>"\ S5"SS\R,55r \!S:Xa\RD"5 gg)") OrderedDictN)*)Vector2PyPyc[R"U5n[USUS-S-5HNn[R"SUSS- 5[R"SUSS- 5pCUR X445 MP U$)zsrandom_mask(size=(100,100)): return Mask Create a mask of the given size, with roughly half the bits set at random.r)pygameMaskrangerandomrandintset_at)sizemixys N/var/www/auris/envauris/lib/python3.13/site-packages/pygame/tests/mask_test.py random_maskrsu  DA 47T!W$) *~~aa1-v~~aa1/M1 !+ Hc@[R"UR55nUR5nU(at[ UR 55HUn[ UR 55H5nURUS-US-45U:wdM"URXT4S5 M7 MW U$[ UR 55HQn[ UR 55H1nURXT45SU:dMURXT4S5 M3 MS U$)Ng?r) r r get_size get_colorkeyr get_height get_widthget_atr)surface thresholdmaskkeyrrs rmaskFromSurfacer#s ;;w'') *D    C w))+,A7,,./>>1s7AG"45<KK*0- K w))+,A7,,./>>1&)!,y8KK*0- KrcUSS=pUSS=p4USSH1upV[XQ5n[XR5n[Xc5n[Xd5nM3 [R"X4X!- S-XC- S-45$)z.Creates a bounding rect from the given points.rrN)minmaxr Rect)pointsxminxmaxyminymaxrrs rcreate_bounding_rectr-*s~)A,D)A,Dqr 1|1|1|1|  ;;|dkAot{Q%G HHrc2^X4US4SU4S4mU4SjT5$)zxCreates a generator which yields pairs of sizes. For each pair of sizes at least one of the sizes will have a 0 in it. rrrc3Z># UH nTHnSU;dSU;dMX4v M M" g7frN).0absizess r "zero_size_pairs..?s) EEq5aAFa1fFQF5FEs++r2)widthheightr6s @rzero_size_pairsr;8s( _uaj1f+v >E EE EErcVUR5upSUS- S4US- US- 4SUS- 44$)zbReturns a tuple with the corner positions of the given mask. Clockwise from the top left corner. r/rr)r)r!r9r:s rcornersr=Bs= MMOME UQYNUQY $;a!_ MMrcvURS- UR4URS- URS- 4URURS- 4URS- URS- 4URURS- 4URUR4URURS- 4URUR4URS- UR4URUR4URS- UR4URS- URS- 44 $)znReturns a tuple with the positions off of the corners of the given rect. Clockwise from the top left corner. r)lefttoprightbottom)rects r off_cornersrDKs Q! Q1 % DHHqL! aA& TXX\" TXX T[[1_% T[[! a% DKK Q $ Q a(  rc^Uc3[UR55m[UR55nOoUR5 UR UR 55n[UR UR5m[URUR5nUR5 U4SjU5H$nURURU5X%5 M& UR5 g)zChecks to see if the given surface is filled with the given color. If an area_rect is provided, only check that area of the surface. Nc3>># UHnTHo"U4v M M g7fNr2r3rrx_ranges rr7&assertSurfaceFilled..o91AA)r rr normalizeclipget_rectr?rAr@rBlock assertEqualrunlock)testcaserexpected_color area_recty_rangeposrIs @rassertSurfaceFilledrX`s ))+,**,-NN7#3#3#56   8 y'7'78 LLN99W^^C0.F: NNrcb^[UR55m[UR55nUR5 UR 5 U4SjU5H<nUR U5(aMUR URU5X%5 M> UR5 g)z[Checks if the surface is filled with the given color. The ignore_rect area is not checked. c3>># UHnTHo"U4v M M g7frGr2rHs rr70assertSurfaceFilledIgnoreArea..}rKrLN) r rrrMrP collidepointrQrrR)rSrrT ignore_rectrVrWrIs @rassertSurfaceFilledIgnoreArear^tsG%%'(GG&&()G LLN99'',,  !4n J: NNrcUR5nURUR5UR5US9 URXBR5US9 URXARUS5US9 g)z-Checks to see if the 2 given masks are equal.)msgr/N)countrQr overlap_area)rSm1m2r`m1_counts rassertMaskEqualrfsexxzH  3? 88:37 ??2v#>CHrcj \rSrSrSr\R "\S5S5rSr Sr \R "\S5S5r Sr S r S rS rS rS rSrSr\R "\S5S5rSrSr\R "\S5S5rSrSrSrSrSrSrSrSrSr Sr!Sr"Sr#\R "\S5S 5r$\R "\S5S!5r%S"r&\R "\S5S#5r'\R "\S5S$5r(S%r)\R "\S5S&5r*S'r+S(r,S)r-\R "\S5S*5r.S+r/\R "\S5S,5r0S-r1\R "\S5S.5r2S/r3S0r4S1r5S2r6\R "\S5S35r7S4r8S5r9\R "\S5S65r:S7r;S8r<\R "\S5S95r=\R "\S5S:5r>S;r?S<r@S=rAS>rBS?rC\R "\S5S@5rDSArESBrFSCrGSDrHSErISFrJ\R "\S5SG5rKSHrLSIrMSJrN\R "\S5SK5rOSLrPSMrQSNrRSOrSSPrTSQrUSRrVSSrWSTrXSUrYSVrZSWr[SXr\SYr]SZr^S[r_S\r`S]ra\R "\S5S^5rbSS_jrcSS`jrdSSajreSbrfScrgSdrhSeriSfrjSgrkShrlSirmSjrnSkroSlrp\R "\S5Sm5rq\R "\S5Sn5rrSorsSprtSqruSrrvSsrwStrxSurySvrzSwr{Sxr|\RSy5r~SzrS{rS|rS}rS~rSrSrSrSrSrSrSrSrSrSrSr\RS5r\RS5r\RS5r\RS5rSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSr\R "\S5S5rSr\R\R "\S5S55r\RS5r\RS5rSrSrSrSrSrSrSrSrSrSrSrSrSr\R\R "\S5S55r\RS5r\R\R "\S5S55r\R\R "\S5S55rSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrg) MaskTypeTest) r/rrrrrrrrrnrnrnrnrrnrzSegfaults on pypyc,SnSn[RRU5n[RRUS9nURU[RR5 UR UR 5U5 UR UR 5U5 URU[RR5 UR UR 5U5 UR UR 5U5 g)z:Ensure masks are created correctly without fill parameter.r rN)r r!r assertIsInstancerQrar)selfexpected_count expected_sizemask1mask2s r test_maskMaskTypeTest.test_masks    /   m 4 eV[[%5%56 7 )=9 eV[[%5%56 7 )=9rcSH7nUR[5 [R"U5nSSS5 M9 g!,(df  MK=f)z=Ensure the mask constructor handles negative sizes correctly.)rmrrrpN) assertRaises ValueErrorr r ryrr!s rtest_mask__negative_size%MaskTypeTest.test_mask__negative_sizes70D"":.{{4(/.1..s ? A clSupX4nX-SS.nUR5HupVSU3n[RRX5S9nUR U[RRU5 UR UR 5Xg5 UR UR5X75 M g)z:Ensure masks are created correctly using the fill keyword.)%/rTFfill=fillNitemsr r!r rxrQrar ryr9r:r{ fill_countsrrzr`r!s rtest_mask__fill_kwarg"MaskTypeTest.test_mask__fill_kwargs  "^A6 $/$5$5$7 D$.C;;##M#=D  ! !$ (8(8# >   TZZ\> ?   T]]_m A%8rcz[SS5Hn[SS5HnX!-nX!4nSU3n[RRUSS9nUR U[RRU5 UR UR 5X55 UR UR5XE5 M M g)zEnsures masks are created correctly using the fill keyword over a range of sizes. Tests masks of different sizes, including: -masks 31 to 33 bits wide (32 bit boundaries) -masks 63 to 65 bits wide (64 bit boundaries) rBsize=TrN)r r r!r rxrQrar)ryr:r9rzr{r`r!s r$test_mask__fill_kwarg_bit_boundaries1MaskTypeTest.test_mask__fill_kwarg_bit_boundariessAqkFq"!&!& m_-{{'' D'A%%dFKK,<,   TZZ\> ?   T]]_m A%8rcSupX4nX-SS.nUR5GHupVSU3n[RRXSS9n[RRX5S9n UR U[RRU5 UR U [RRU5 UR UR 5Xg5 UR U R 5Xg5 UR UR5X75 UR U R5X75 GM g)z:Ensure masks are created correctly using the size keyword.)ISrrrrr)rrNr) ryr9r:r{rrrzr`r|r}s rtest_mask__size_kwarg"MaskTypeTest.test_mask__size_kwargs  "^A6 $/$5$5$7 D$.CKK$$$$CEKK$$-$CE  ! !%)9)93 ?  ! !%)9)93 ?   U[[]N @   U[[]N @   U^^-} B   U^^-} B%8rcSHnSHn[RRX45n[U5H,n[US-US5HnUR XE45 M M. UR 5[ R "U54HJnUR U[RR5 URXc5 [XU5 ML M M g)z:Ensures copy works correctly with some bits set and unset. !?@Arr N) r r!r r rcopyrx assertIsNotrf)ryr9r:r!rr mask_copys r test_copyMaskTypeTest.test_copys.E2{{''8uA"1q5&!4 QF+5& #'))+tyy!?I)))V[[5E5EF$$Y5#DT:"@3.rcNSHnSHn[RRX4SS9nUR5[R"U54HJnUR U[RR5 UR XC5 [ XU5 ML M M g)z0Ensures copy works correctly on a filled masked.rTrNr r!r rrxrrfryr9r:r!rs rtest_copy__fullMaskTypeTest.test_copy__fulls.E2{{''d'C#'))+tyy!?I)))V[[5E5EF$$Y5#DT:"@ 3.rcPSHnSHn[RRX45nUR5[R"U54HJnUR U[RR5 UR XC5 [ XU5 ML M M g)z.Ensures copy works correctly on an empty mask.rNrrs rtest_copy__emptyMaskTypeTest.test_copy__emptys~-E2{{''8#'))+tyy!?I)))V[[5E5EF$$Y5#DT:"@ 3.rcSnSn[RRS5nUR5[R"U54nUR U5 UHnUR U5 UR XS5 UR URU5URU55 UR URU5URU55 M g)z3Ensures copy makes an independent copy of the mask.)rr)rr rrN)r r!r rrrassertNotEqualr)ry mask_set_posmask_copy_set_posr! mask_copiesrs rtest_copy__independent#MaskTypeTest.test_copy__independent's #{{(yy{DIIdO4  L!$I   . /   Y -     . L0I      !23T[[AR5S %rcSn[RRU5nURUR 5U5 g)z,Ensure a mask's size is correctly retrieved.)]eN)r r!r rQr)ryr{r!s r test_get_sizeMaskTypeTest.test_get_size<s1! {{ . -8rc[R"SS5nSHLn[RRURUS9nUR 5nUR XA5 MN g)z!Ensures get_rect works correctly.r/ru rrN)r r'r!r rrOrQ)ry expected_rectrr!rCs r test_get_rectMaskTypeTest.test_get_rectCsV FH5 "D;;##M$6$6T#BD==?D   T 1 "rc \SnSnUSUSSS/[SS540nS n[RRU5nUR 5H^upgUHSnUHJn [R "S U5n [ XU 5 UR"S 0X0D6n URX5 ML MU M` g ) zYEnsures get_rect supports a single rect attribute kwarg. Tests all the rect attributes. ) rrr@r?rBrAcenterxcenteryr9r:wh) topleft bottomlefttopright bottomrightmidtopmidleft midbottommidrightcenterr)rgffffff@)rg@gffffff@rrrrr/Nr2) rr r!r rr'setattrrOrQ) ryRECT_SINGLE_VALUE_ATTRIBUTESRECT_DOUBLE_VALUE_ATTRIBUTESrect_attributesrr! attributesvalues attributevaluerrCs rtest_get_rect__one_kwarg%MaskTypeTest.test_get_rect__one_kwargOs ( $ ( $ )( (8c1Xwq!}*M  {{%"1"7"7"9 J' #E$*KK$=MMe<==>I+=>D$$T9 $(#:rc [RRS5n[R"SS5nSS[ SS5S.nUR 5HupE[ X$U5 M UR"S 0UD6nURXb5 g) z9Ensures get_rect supports multiple rect attribute kwargs.rr/gffffff@rnr g @)rr@rNr2) r r!r r'rrrrOrQ)ryr!rkwargsattribrrCs rtest_get_rect__multiple_kwargs+MaskTypeTest.test_get_rect__multiple_kwargssu{{' FF3 2wq#?#\\^MF M5 1,}}&v& -rcB[RRS5nUR[5 UR S5nSSS5 UR[5 UR S5nSSS5 g!,(df  N>=f!,(df  g=f)z&Ensures get_rect only supports kwargs.rrrNrr r r!r r TypeErrorrOryr!rCs rtest_get_rect__no_arg_support*MaskTypeTest.test_get_rect__no_arg_supportso{{'   y )==#D*  y )==(D* )* )* )sA?$B? B  Bc[RRS5nUR[5 UR SS9nSSS5 UR[5 UR SS9nSSS5 UR[5 UR SS9nSSS5 g!,(df  Ni=f!,(df  NM=f!,(df  g=f) z(Ensures get_rect detects invalid kwargs.rru)righteNrk)toplefrr )move)r r!r rAttributeErrorrOrs r!test_get_rect__invalid_kwarg_name.MaskTypeTest.test_get_rect__invalid_kwarg_names{{'   ~ .===+D/  ~ .===/D/  ~ .==f=-D/ . / ./ ./ .s#B("B9C ( B69 C Cc[RRS5nUR[5 UR SS9nSSS5 UR[5 UR SS9nSSS5 UR[5 UR SS9nSSS5 UR[5 UR S S 9nSSS5 UR[5 UR SS 9nSSS5 UR[5 UR S S 9nSSS5 UR[5 UR SS9nSSS5 g!,(df  GN=f!,(df  GN=f!,(df  N=f!,(df  N=f!,(df  N=f!,(df  N=f!,(df  g=f)z/Ensures get_rect detects invalid kwarg formats.)rru1)rANr)rBrk)r)rr)r)rrr r)rr)rrrs r#test_get_rect__invalid_kwarg_format0MaskTypeTest.test_get_rect__invalid_kwarg_formatsY{{(   y )==s=+D*  y )===-D*  y )===0D*  y )===2D*  y )==$=/D*  y )==I=6D*  y )==1=-D* )%* )* )* )* )* )* )* )sSE"E.F<F)F"F3G E+. E= F F" F03 G GcSup[RRX45n[RRX4SS9nSnSnUS- US- 4nURUR U5U5 URUR US9U5 URUR [ U55U5 URUR [ U5S9U5 g)z4Ensure individual mask bits are correctly retrieved.rrTrrr)rWN)r r!r rQrr)ryr9r:mask0r|mask0_expected_bitmask1_expected_bitrWs r test_get_atMaskTypeTest.test_get_ats    %1   %t <qy&1*% c*,>? #.0BC gcl35GH '#,79KLrcTSup[RRX45nUR[5 UR US45 SSS5 UR[5 UR SU45 SSS5 UR[5 UR S5 SSS5 UR[5 UR S5 SSS5 g!,(df  N=f!,(df  N~=f!,(df  N`=f!,(df  g=f)zEnsure get_at() checks bounds.rurrNrqror r!r r IndexErrorrryr9r:r!s rtest_get_at__out_of_bounds'MaskTypeTest.test_get_at__out_of_bounds {{0   z * KK #+  z * KKF $+  z * KK +  z * KK + *+ *+ *+ *+ */C&+C7D D& C47 D D D'cSup[RRX45n[RRX4SS9nSnUR5nSnUS- US- 4nUR X5 UR [ U5US9 UR URU5U5 UR UR5U5 UR URU5U5 UR UR5U5 g)z)Ensure individual mask bits are set to 1.rTrr)rWrN)r r!r rarrrQr ryr9r:rr|mask0_expected_countmask1_expected_count expected_bitrWs r test_set_atMaskTypeTest.test_set_ats    %1   %t < ${{} qy&1*% S' \ : c*L9 (<= c*L9 (<=rcSup[RRX45n[RRX4SS9nSnUR5S- nSnUS- US- 4nUR X5 UR X5 UR UR U5U5 UR UR5U5 UR UR U5U5 UR UR5U5 g)z)Ensure individual mask bits are set to 0.rurTrrrNr r!r rarrQrrs rtest_set_at__to_0MaskTypeTest.test_set_at__to_0s    %1   %t < ${{}q0 qy&1*% S' S' c*L9 (<= c*L9 (<=rcSup[RRX45n[RRX4SS9nSnUR5nSnUS- US- 4nUR U5 UR U5 UR UR U5U5 UR UR5U5 UR UR U5U5 UR UR5U5 g)zEnsure an offset overlap intersection is correctly calculated.rTrrroffset=rrotherr/N) r r!r rarORIGIN_OFFSETSr&r.rQ) ryr|r}r5r3 mask1_size mask2_sizer/r`r6r7s rtest_overlap__offset!MaskTypeTest.test_overlap__offsetOs   t 4   t 4kkm kkm ^^% ^^% ))FF8$Cq 1-s6!9a/@AL--e-CK   [ <   U[[]K =   U[[]K =   U^^-z ?   U^^-z ?*rc[RRSSS9n[RRSSS9nSnURUS5 URUS5 UR 5nUR 5nUR 5nUR 5nUR GHDnSU3n Uup[U S5n SU :Xa[U S-S5n O"SU :a[U S-S5n O [U S5n URU[U55nURXU 4U 5 URUR 5XI5 URUR 5XY5 URUR 5Xi5 URUR 5Xy5 URURU5SU 5 URURU5SU 5 GMG g ) zWEnsure an offset overlap intersection is correctly calculated when (0, 0) bits not set.rTrr;r/rr<rN) r r!r rrarr?r&r.rrQr)ryr|r} unset_posr5r3r@rAr/r`rr expected_y expected_xr7s r$test_overlap__offset_with_unset_bits1MaskTypeTest.test_overlap__offset_with_unset_bitsfs   t 4   t 4  Y" Y"kkm kkm ^^% ^^% ))FF8$CDAQJAv Q] Q Q]  AY --wv?K   [z*BC H   U[[]K =   U[[]K =   U^^-z ?   U^^-z ?   U\\)4a =   U\\)4a =+*rc[RRSSS9nUR5nUR 5nSupEXE4n[RRU5nUS- US- 4nUR U5 Sn UR Hn SU 3n URXz5n URX5 URUR5X+5 URUR5X5 URUR 5X;5 URUR 5Xk5 URURU5SU 5 M g)zWEnsure an offset overlap intersection is correctly calculated when there is no overlap.rTr)Crrr<N) r r!r rarrr?r. assertIsNonerQr) ryr|r5r@mask2_wmask2_hrAr}set_posr3r/r`r7s rtest_overlap__no_overlap%MaskTypeTest.test_overlap__no_overlaps*   t 4kkm ^^%  '    ,Q;! , W ))FF8$C--6K   k /   U[[]K =   U[[]K =   U^^-z ?   U^^-z ?   U\\'2As ;*rc[RRSSS9n[RRSSS9nUR5nUR5nUR 5nUR 5nUSS4SUS4US*S4SUS*44nUHnSU3n UR X(5n UR X5 URUR5X95 URUR5XI5 URUR 5XY5 URUR 5Xi5 M g) z9Ensures overlap handles offsets and boundaries correctly.)rrTrrrrrr<N)r r!r rarr.rLrQ) ryr|r}r5r3r@rAoffsetsr/r`r7s rtest_overlap__offset_boundary*MaskTypeTest.test_overlap__offset_boundarys/   t 4   d 3kkm kkm ^^% ^^% ]A   1 m^Q  A   FF8$C--6K   k /   U[[]K =   U[[]K =   U^^-z ?   U^^-z ?rc[SS5GH8n[SS5GH#nX!4nX!-n[RRUSS9n[RRUSS9nURHnSUSU3n[ USS5[ US S54n UR Xg5n URXU5 URUR5XH5 URUR5XH5 URUR5X85 URUR5X85 M GM& GM; g ) zEnsures overlap handles masks of different sizes correctly. Tests masks of different sizes, including: -masks 31 to 33 bits wide (32 bit boundaries) -masks 63 to 65 bits wide (64 bit boundaries) r rrTrr , offset=rrN) r r r!r r?r&r.rQrar) ryr:r9 mask_size mask_countr|r}r/r`r6r7s rtest_overlap__bit_boundaries)MaskTypeTest.test_overlap__bit_boundariess"AqkFq""O "^  (((> (((>#11F!)IfX>C$'q 1$5s6!9a7H#IL"'--">K$$[D$$U[[]JD$$U[[]JD$$U^^%5yF$$U^^%5yF2&"rcSnSn[RRU5n[R"U5nUR [ 5 UR XB5nSSS5 g!,(df  g=f)z8Ensure overlap handles invalid mask arguments correctly.rrr/N)r r!r Surfacerrr.)ryrr/r! invalid_maskr7s rtest_overlap__invalid_mask_arg+MaskTypeTest.test_overlap__invalid_mask_argsX{{%~~d+   y ),,|   t 4   t 4kkm kkm ^^% ^^%   ))FF8$C"M ::e,L)^^lnnEnsures overlap_area handles offsets and boundaries correctly.r Trrrrr<N)r r!r rarrbrrQ) ryr|r}r5r3r@rArzrTr/r`rks r"test_overlap_area__offset_boundary/MaskTypeTest.test_overlap_area__offset_boundary9s>   t 4   d 3kkm kkm ^^% ^^% ]A   1 m^Q  A   FF8$C!..ugfoFM   ]C @   U[[]K =   U[[]K =   U^^-z ?   U^^-z ?rc[SS5GHjn[SS5GHUnX!4nX!-n[RRUSS9n[RRUSS9nUR 5nUR 5nUR Hn SUSU 3n XlURU5n U RU R-n URXi5n URXU 5 URUR5XJ5 URUR5XJ5 URUR5X:5 URUR5X:5 M GMX GMm g) zEnsures overlap_area handles masks of different sizes correctly. Tests masks of different sizes, including: -masks 31 to 33 bits wide (32 bit boundaries) -masks 63 to 65 bits wide (64 bit boundaries) r rrTrrrXN)r r r!r rOr?rrNrrrbrQrar)ryr:r9rYrZr|r}rorpr/r`rqexpected_overlap_countrks r!test_overlap_area__bit_boundaries.MaskTypeTest.test_overlap_area__bit_boundariesXsDAqkFq""O "^  (((> (((>((#11F!)IfX>C$*M#(::e#4L-9^^lnn-L*$)$6$6u$EM$$]CP$$U[[]JD$$U[[]JD$$U^^%5yF$$U^^%5yF2&"rcSnSn[RRU5n[R"U5nUR [ 5 UR XB5nSSS5 g!,(df  g=f)z=Ensure overlap_area handles invalid mask arguments correctly.rrr/N)r r!r r_rrrb)ryrr/r!r`rks r#test_overlap_area__invalid_mask_arg0MaskTypeTest.test_overlap_area__invalid_mask_arg|sX{{%~~d+   y ) --lCM* ) )rccSnSn[RRU5n[RRU5nUR[5 UR XB5nSSS5 g!,(df  g=f)z?Ensure overlap_area handles invalid offset arguments correctly.)rr reN)r r!r rrrb)ryrr/r|r}rks r%test_overlap_area__invalid_offset_arg2MaskTypeTest.test_overlap_area__invalid_offset_args^   &   &   y )!..u=M* ) )rhc(SnSn[RRU5nS[RRUSS90nSGHHn[RRXS9nUR5nSGHnX4n SU 3n [RRXS9n U R5n UR X5n U R XbS9nUR U[RRU 5 [XX5 URU R5X5 URUR5Xz5 URU R5X5 URUR5X5 GM GMK g ) a4Ensure overlap_mask's mask has correct bits set. Testing the different combinations of full/empty masks: (mask1-filled) 1 overlap_mask 1 (mask2-filled) (mask1-empty) 0 overlap_mask 1 (mask2-filled) (mask1-filled) 1 overlap_mask 0 (mask2-empty) (mask1-empty) 0 overlap_mask 0 (mask2-empty) r*r/r+Trrr,r=N) r r!r rar- overlap_maskrxrfrQr)ryr{r/r0expected_masksr2r}r3r4r"r`r|r5 expected_maskrs rtest_overlap_maskMaskTypeTest.test_overlap_masksP !;;++M:& (8(8T(8(RS"EKK$$]$?E++-K&nSEl (((C#kkm . 2 23 I $111M %%lFKK4D4DcJMG   A   A  !1=F  !1=F!' #rc Z[RRSSS9n[RRSSS9nUR5nUR5nUR 5nUR 5nUR US5n[ S5H?n[ S5H-n URURX45SS US U S 35 M/ MA [ S5H@n[ S S5H-n URURX45S S US U S 35 M/ MB URUR5U5 URUR5U5 URUR 5U5 URUR 5U5 g)z0Ensure overlap_mask's mask has correct bits set.2rTr)i, rqrrr(, )rurN) r r!r rarrr rQr) ryr|r}r5r3r@rAmask3rjs rtest_overlap_mask__bits_set(MaskTypeTest.test_overlap_mask__bits_setsd    5    6kkm kkm ^^% ^^% ""5'2rA2Y  qf!5qAaS1#Q-HrA2r]  qf!5qAaS1#Q-H#  4  4 ):6 ):6rc[RRSSS9n[RRSSS9nUR5nUR5nUR 5nUR 5n[R"U5nUR 5nUR 5n UR GH1n SU 3n XlURU 5n UR5 UR[R"U RSS9U R5 URX*5n URU [RRU 5 [X X{5 URUR5X;5 URUR5XK5 URUR 5X[5 URUR 5Xk5 GM4 g)z=Ensure an offset overlap_mask's mask is correctly calculated.rTrr;r<N)r r!r rarrOr?rrNcleardrawrrrxrfrQ)ryr|r}r5r3r@rArrorpr/r`rqrs rtest_overlap_mask__offset&MaskTypeTest.test_overlap_mask__offsets   t 4   t 4kkm kkm ^^% ^^%  J/   ))FF8$C"M ::e,L    !    L--D9<;O;O !--eEnsures overlap_mask handles offsets and boundaries correctly.) rTr)rurrrr<N)r r!r rarrrxrQ) ryr|r}r5r3r@rArzr{rTr/r`rs r"test_overlap_mask__offset_boundary/MaskTypeTest.test_overlap_mask__offset_boundarys{   d 3   t 4kkm kkm ^^% ^^% " ]A   1 m^Q  A   FF8$C --e G   \224m I   U[[]K =   U[[]K =   U^^-z ?   U^^-z ?rc [SS5GHn[SS5GHnX!4nX!-n[RRUSS9n[RRUSS9n[R"U5nUR 5nUR 5n UR GH4n SUSU 3n XlURU 5n UR5 UR[R"U RSS9U R 5 URXj5n URU [RRU 5 [X X{5 URUR5XK5 URUR5XK5 URUR!5X;5 URUR!5X;5 GM7 GM GM g) zEnsures overlap_mask handles masks of different sizes correctly. Tests masks of different sizes, including: -masks 31 to 33 bits wide (32 bit boundaries) -masks 63 to 65 bits wide (64 bit boundaries) r rrTrrrXN)r r r!r rOr?rrNrrrrrxrfrQrar)ryr:r9rYrZr|r}rrorpr/r`rqrs r!test_overlap_mask__bit_boundaries.MaskTypeTest.test_overlap_mask__bit_boundaries6sAqkFq""O "^  (((> (((> & I 6 ((#11F!)IfX>C$*M#(::e#4L!'')!&& L$5$5DATRS5$)Nrq)rrsr/MaskTypeTest.test_mask_access..sahhw.?rc(>TRSS5$)Nrqrrrsrrrahhw.Brc(>TRSS5$)Nrrrrrsrrrrrc(>TRSS5$)NrrrrrsrrrrrN)r r rrQrrr ryrs @rtest_mask_accessMaskTypeTest.test_mask_accessss KK !  &)1-  &)1- *&?@ *&BC *&BC *&BCrcSupX-nX4n[RRU5nUR5 UR UR 5U5 UR UR 5U5 g)zEnsure a mask can be filled.rtN)r r!r rrQrar)ryr9r:rzr{r!s r test_fillMaskTypeTest.test_fills`  {{ .  ~6 -8rc [SS5Hrn[SS5H_n[RRX!45nX!-nUR 5 UR UR 5USUSUS35 Ma Mt g)zEnsures masks of different sizes are filled correctly. Tests masks of different sizes, including: -masks 31 to 33 bits wide (32 bit boundaries) -masks 63 to 65 bits wide (64 bit boundaries) rrrsize=(rrN)r r r!r rrQra)ryr:r9r!rzs rtest_fill__bit_boundaries&MaskTypeTest.test_fill__bit_boundariesstAqkFq"{{''8!&   JJL.F5'F812M &"rcSnSn[RRUSS9nUR5 UR UR 5U5 UR UR 5U5 g)zEnsure a mask can be cleared.rrTrN)r r!r rrQrarryrzr{r!s r test_clearMaskTypeTest.test_clearsZ {{ D9  ~6 -8rc Sn[SS5Hmn[SS5HZn[RRX24SS9nUR 5 UR UR 5USUSUS 35 M\ Mo g ) zEnsures masks of different sizes are cleared correctly. Tests masks of different sizes, including: -masks 31 to 33 bits wide (32 bit boundaries) -masks 63 to 65 bits wide (64 bit boundaries) rrrrTrrrrN)r r r!r rrQra)ryrzr:r9r!s rtest_clear__bit_boundaries'MaskTypeTest.test_clear__bit_boundariesswAqkFq"{{''d'C   JJL.F5'F812M &"rcSnX4n[RRU5n[RRUSS9nX-nSn[U5H3nUS-nUS- nXw4nUR U5 UR US5 M5 UR 5 UR 5 UR UR5U5 UR UR5U5 UR UR5U5 UR UR5U5 [U5HOnXw4nSU3n UR URU5SU 5 UR URU5SU 5 MQ g)zEnsure a mask can be inverted.rTrrrzpos=N) r r!r r rinvertrQrarr) rysider{r|r}expected_count1expected_count2rrWr`s r test_invertMaskTypeTest.test_invertsP    /   T :+tA q O q O&C LL  LLa     8 8 )=9 )=9tA&C,C   U\\#.3 7   U\\#.3 7 rcSnSn[RRUSS9nUR5 UR UR 5U5 UR UR 5U5 g)z#Ensure a full mask can be inverted.r+aTrNr r!r rrQrarrs rtest_invert__fullMaskTypeTest.test_invert__fullsZ {{ D9  ~6 -8rcSupX4nX-n[RRU5nUR5 UR UR 5U5 UR UR 5U5 g)z%Ensure an empty mask can be inverted.rNr)ryr9r:r{rzr!s rtest_invert__emptyMaskTypeTest.test_invert__emptys`  {{ .  ~6 -8rc0SHn[SS5H}n[SS5Hjn[RRX24US9nU(aSOX2-nUR 5 UR UR 5USUSUS US 35 Ml M M g ) zEnsures masks of different sizes are inverted correctly. Tests masks of different sizes, including: -masks 31 to 33 bits wide (32 bit boundaries) -masks 63 to 65 bits wide (64 bit boundaries) rrrrrrr, size=(rrN)r r r!r rrQra)ryrr:r9r!rzs rtest_invert__bit_boundaries(MaskTypeTest.test_invert__bit_boundariess"D1+"1b\E!;;++UO$+GD*.QENNKKM$$ &vXeWBvha@ *&"rc~SupX4nSGH/n[RRX4S9nU(aX-OSn[US- US-5Hn[US- US-5HnXx4n U(aXx-OSn SU 3n UR U S9n UR U [RRU 5 UR U R5X5 UR U R5U 5 UR UR5Xk5 UR UR5X;5 M M GM2 g) zEnsure a mask can be scaled.)r=rrrrr)scaleN) r r!r r rrxrQrar) ryr9r: original_sizer original_maskoriginal_countnew_wnew_hr{rzr`r!s r test_scaleMaskTypeTest.test_scales  !D"KK,,],FM/3U^Nurz52:6"6B; G$$T]]_mD$$]%8%8%:NP$$]%;%;%=}R=7 "rc[R"S5nUR[5 UR S5 SSS5 UR[5 UR [ SS55 SSS5 UR[5 UR S5 SSS5 g!,(df  Nw=f!,(df  NO=f!,(df  g=f)z.Ensure scale handles negative sizes correctly.drrpNrnr)rrn)r r rrrrryr!s rtest_scale__negative_size&MaskTypeTest.test_scale__negative_size,s{{:&   z * JJx +  z * JJwr2 '+  z * JJx + * + *+ *+ *s#B/CC/ B= C Cc.SnSn[RRUSS9nS[RRU50nSHn[RRXS9nUR5nSHnX4n SU 3n [RRXS9n UR X5n U R Xb5 [ X X5 URUR5Xz5 URUR5X5 M M g) aEnsure a mask can be drawn onto another mask. Testing the different combinations of full/empty masks: (mask1-filled) 1 draw 1 (mask2-filled) (mask1-empty) 0 draw 1 (mask2-filled) (mask1-filled) 1 draw 0 (mask2-empty) (mask1-empty) 0 draw 0 (mask2-empty) r*r/Tr)FFrr,N) r r!r rar-rrfrQr ryr{r/r0rr2r}r3r4r"r`r|rs r test_drawMaskTypeTest.test_draw9s !;;++M+E(&++*:*:=*IJ"EKK$$]$?E++-K&nSEl (((C . 2 23 I  5)]@   A  !1=F' #rcZ[RRS5n[RRSSS9nUR5nUR 5n[R"UR 55nUR 5nUR 5nUR HnSU3n XlURU5n UR5 [U RU R5H<n [U RU R5Hn URX45 M M> UR5 UR!X(S9 [#XXY5 UR%UR5X95 UR%UR 5XI5 M g)z5Ensure an offset mask can be drawn onto another mask.rr;Trr<r=N)r r!r rarrOr?rrNrr r?rAr@rBrrrfrQ ryr|r}r3rArrorpr/r`rqrrs rtest_draw__offsetMaskTypeTest.test_draw__offsetYsP   )   t 4kkm ^^%  ENN$45   ))FF8$C"M ::e,L    !<,,l.@.@A|//1D1DEA!((!0FB KKM JJUJ 2 D <   U[[]K =   U^^-z ?'*rc [RRS5n[RRSSS9n[R"UR55nUR 5nUR 5nUR SS5nSHn[ XW[Xg55 URnSU3n URU5n UR5 [U RU R5H<n [U RU R5Hn UR!X45 M M> UR5 UR#X(5 [%XX95 M g) zEnsure an offset mask can be drawn onto another mask. Testing the specific case of: -both masks are wider than 32 bits -a positive offset is used -the mask calling draw() is wider than the mask passed in rrTrrrr<N)r r!r rrOrrrrrNrr r?rAr@rBrrrf ryr|r}rrorprrr/r`rqrrs rtest_draw__specific_offsets(MaskTypeTest.test_draw__specific_offsetszs*   )   t 4 ENN$45   mmB+ JF E7;#? @]]FF8$C ::e,L    !<,,l.@.@A|//1D1DEA!((!0FB KKM JJu % D UR5 URXj5 [XX{5 UR!UR#5XK5 UR!UR%5X;5 GM GM GM g) zEnsures draw handles masks of different sizes correctly. Tests masks of different sizes, including: -masks 31 to 33 bits wide (32 bit boundaries) -masks 63 to 65 bits wide (64 bit boundaries) r rrTrrrXN)r r r!r rOr?rrNrr?rAr@rBrrrfrQrarryr:r9rYrZr|r}rrorpr/r`rqrrs rtest_draw__bit_boundaries&MaskTypeTest.test_draw__bit_boundariesshAqkFq""O "^  ((3 (((> & I 6 ((#11F!)IfX>C$*M#(::e#4L!'') #<#4#4l6H6HI!&|'7'79L9L!MA)00!8"NJKKMJJu-#DD$$U[[]JD$$U^^%5yF)2&"rcSnSn[RRU5n[R"U5nUR [ 5 UR XB5 SSS5 g!,(df  g=f)z5Ensure draw handles invalid mask arguments correctly.rr/N)r r!r r_rrrryrr/r!r`s rtest_draw__invalid_mask_arg(MaskTypeTest.test_draw__invalid_mask_argsT{{%~~d+   y ) IIl +* ) )rccSnSn[RRU5n[RRU5nUR[5 UR XB5 SSS5 g!,(df  g=f)z7Ensure draw handles invalid offset arguments correctly.rreN)r r!r rrrryrr/r|r}s rtest_draw__invalid_offset_arg*MaskTypeTest.test_draw__invalid_offset_argsZ   &   &   y ) JJu %* ) )rhc.SnSn[RRU5nS[RRUSS90nSHn[RRXS9nUR5nSHnX4n SU 3n [RRXS9n UR X5n U R Xb5 [ X X5 URUR5Xz5 URUR5X5 M M g)a Ensure a mask can erase another mask. Testing the different combinations of full/empty masks: (mask1-filled) 1 erase 1 (mask2-filled) (mask1-empty) 0 erase 1 (mask2-filled) (mask1-filled) 1 erase 0 (mask2-empty) (mask1-empty) 0 erase 0 (mask2-empty) r*r/rTrr,N) r r!r rar-eraserfrQrrs r test_eraseMaskTypeTest.test_erases !;;++M:')9)9-d)9)ST"EKK$$]$?E++-K&nSEl (((C . 2 23 I  E*]@   A  !1=F' #rc\[RRS5n[RRSSS9nUR5nUR 5n[R"UR 55nUR 5nUR 5nUR HnSU3n XlURU5n UR5 [U RU R5H=n [U RU R5Hn URX4S5 M M? UR5 UR!X(S9 [#XXY5 UR%UR5X95 UR%UR 5XI5 M g) z-Ensure an offset mask can erase another mask.rr;Trr<rr=N)r r!r rarrOr?rrNrr r?rAr@rBrrrfrQrs rtest_erase__offsetMaskTypeTest.test_erase__offsetsR   )   t 4kkm ^^%  ENN$45   ))FF8$C"M ::e,L    <,,l.@.@A|//1D1DEA!((!3FB JJL KKeK 3 D <   U[[]K =   U^^-z ?'*rc [RRS5n[RRSSS9n[R"UR55nUR 5nUR 5nUR SS5nSHn[ XW[Xg55 URnSU3n URU5n UR5 [U RU R5H=n [U RU R5Hn UR!X4S5 M M? UR5 UR#U[%U55 ['XX95 M g ) zEnsure an offset mask can erase another mask. Testing the specific case of: -both masks are wider than 32 bits -a positive offset is used -the mask calling erase() is wider than the mask passed in rrTrrrr<rN)r r!r rrOrrrrrNrr r?rAr@rBrrrrfrs rtest_erase__specific_offsets)MaskTypeTest.test_erase__specific_offsets<s2   )   t 4 ENN$45   mmB+ JF E7;#? @]]FF8$C ::e,L    <,,l.@.@A|//1D1DEA!((!3FB JJL KKwv / D  & I 6 ((#11F!)IfX>C$*M#(::e#4L!&&( #<#4#4l6H6HI!&|'7'79L9L!MA)00!;"NJJJLKK.#DD$$U[[]JD$$U^^%5yF)2&"rcSnSn[RRU5n[R"U5nUR [ 5 UR XB5 SSS5 g!,(df  g=f)z6Ensure erase handles invalid mask arguments correctly.rrr/N)r r!r r_rrrr s rtest_erase__invalid_mask_arg)MaskTypeTest.test_erase__invalid_mask_argsT{{%~~d+   y ) JJ| ,* ) )rccSnSn[RRU5n[RRU5nUR[5 UR XB5 SSS5 g!,(df  g=f)z8Ensure erase handles invalid offset arguments correctly.rSreN)r r!r rrrrs rtest_erase__invalid_offset_arg+MaskTypeTest.test_erase__invalid_offset_argsZ   &   &   y ) KK &* ) )rhc$SnX4nSn[RRU5n[U5HnUS- nUR XU45 M UR 5nUR Xc5 UR UR5U5 g)z/Ensure a mask's set bits are correctly counted.rKrrN)r r!r r rrarQr)ryrr{rzr!rras r test_countMaskTypeTest.test_counts~ {{ .tA a N KK   / -8rc^SHn[SS5Hn[SS5Hm[RRTU4US9nU(aTU-OSnU4Sj[U55HhnU(aUR US5 US-nOUR US5 US- nUR 5nUR UUSUS TS US U35 Mj M M M g ) zEnsures the set bits of different sized masks are counted correctly. Tests masks of different sizes, including: -masks 31 to 33 bits wide (32 bit boundaries) -masks 63 to 65 bits wide (64 bit boundaries) rrrrrrc3P># UHn[T5Ho"U4v M M g7frGr r3rrr9s rr7:MaskTypeTest.test_count__bit_boundaries..sT 1uU|!A| #&rrrz), pos=N)r r r!r rrarQ)ryrr:r!rzrWrar9s @rtest_count__bit_boundaries'MaskTypeTest.test_count__bit_boundariess"D1+"1b\E!;;++UFO$+GD7;UV^N Uf T KKQ/*a/N KKQ/*a/N $ ((!*#D6%6('#O U *&"rcSupX4nX-n[RRUSS9nUR5nUR Xd5 UR UR 5U5 g)z4Ensure a full mask's set bits are correctly counted.)rrTrNr r!r rarQr)ryr9r:r{rzr!ras rtest_count__full_mask"MaskTypeTest.test_count__full_masks_  {{ D9  / -8rcSnSn[RRU5nUR5nUR XA5 UR UR 5U5 g)z6Ensure an empty mask's set bits are correctly counted.rrNr6)ryrzr{r!ras rtest_count__empty_mask#MaskTypeTest.test_count__empty_masksO {{ .  / -8rc[RRSSS9nUR5RnUR 5nUR X25 g)z8Ensure a filled mask's centroid is correctly calculated.rTrN)r r!r rOrcentroidrQ)ryr!expected_centroidr=s r test_centroidMaskTypeTest.test_centroidsF{{T2 MMO22==? 5rcSnSn[RRU5nUR5nUR XA5 UR UR 5U5 g)z8Ensure an empty mask's centroid is correctly calculated.r/)rgN)r r!r r=rQr)ryr>r{r!r=s rtest_centroid__empty_mask&MaskTypeTest.test_centroid__empty_mask sP"" {{ .==? 5 -8rc(Sup[RRX45n[U5H_nUR 5 [U5H=nUR XT45 US-U4nUR 5nURXv5 M? Ma g)zXEnsure a mask's centroid is correctly calculated when setting points along a single row.rr Nr r!r r rrr=rQryr9r:r!rrr>r=s rtest_centroid__single_row&MaskTypeTest.test_centroid__single_rows{ {{0vA JJL5\ QF#%&!VQK!==?  = "rcVSup[RRX45n[SU5HunUR 5 [U5HSnUR US45 UR XT45 US-US-4nUR 5nURXv5 MU Mw g)zTEnsure a mask's centroid is correctly calculated when setting points along two rows.rrrr NrFrGs rtest_centroid__two_rows$MaskTypeTest.test_centroid__two_rows(s {{0q&!A JJL5\ QF# QF#%&!VQ!V$4!==?  =""rc&Sup[RRX45n[U5H^nUR 5 [U5H<nUR XE45 XES-4nUR 5nURXv5 M> M` g)z[Ensure a mask's centroid is correctly calculated when setting points along a single column.rr NrFryr9r:r!rrr>r=s rtest_centroid__single_column)MaskTypeTest.test_centroid__single_column;sy {{0uA JJL6] QF#%&QK!==?  = #rcVSup[RRX45n[SU5HunUR 5 [U5HSnUR SU45 UR XE45 US-US-4nUR 5nURXv5 MU Mw g)zWEnsure a mask's centroid is correctly calculated when setting points along two columns.rrrr NrFrNs rtest_centroid__two_columns'MaskTypeTest.test_centroid__two_columnsLs {{0q%A JJL6] QF# QF#%&!VQ!V$4!==?  =#!rc[RRS5nUR5Rn[ U5HnUR U5 M UR5nURXB5 g)zJEnsure a mask's centroid is correctly calculated when its corners are set.rN) r r!r rOrr=rr=rQ)ryr!r>rr=s rtest_centroid__all_corners'MaskTypeTest.test_centroid__all_corners_s_{{' MMO22dmF KK $==? 5rc[RRS5nUR5n[ U5n[ U5HupEX4S-SHnUR 5 URU5 URU5 USUS:XaUS[USUS- 5S-4nO5USUS:Xa[USUS- 5S-US4nO URnUR5nURX5 M M g)zOEnsure a mask's centroid is correctly calculated when only two corners are set.rrNrr ) r r!r rOr= enumeraterrabsrr=rQ) ryr! mask_rect mask_cornersrcorner1corner2r>r=s rtest_centroid__two_corners'MaskTypeTest.test_centroid__two_cornersls{{'MMO t} #L1JA'A0  G$ G$1:+)0Sgaj9P5QUV5V(W%QZ71:-),WQZ'!*-D)E)JGTUJ(W%(1(8(8%==?  =12rcSnSn[R"U5n[RRU5nUR 5nUR U[ 5 URXQ5 g)z:Ensure a mask's orientation angle is correctly calculated.gFrN)r r_r! from_surfaceanglerxfloatrQ)ryexpected_angler{rr!rbs r test_angleMaskTypeTest.test_anglesW" ../{{''0  eU+ /rcSnSn[RRU5nUR5nUR U[ 5 UR XA5 URUR5U5 g)z5Ensure an empty mask's angle is correctly calculated.)krN) r r!r rbrxrcassertAlmostEqualrQr)ryrdr{r!rbs rtest_angle__empty_mask#MaskTypeTest.test_angle__empty_masks_! {{ .  eU+ u5 -8rc[R"S5nURUR5S5 UR 5 URUR5S5 [R"SSS9nUR US5 URUR5S5 UR 5 URUR5S 5 URUS 5 URUR5S 5 UR5 URUR5S5 g ) z%Test fill, clear, invert, draw, eraserri'rTrri&rr/N) r r rQrarrrrr)ryrrds r test_drawingMaskTypeTest.test_drawings KK # A&  E* [[ - H D)   C( r6 C(   A&rc[R"S5nURUR5/5 UR SS5 URUR5S/5 UR SS5 URURS5S/5 UR SS5 URUR5/SQ5 URURSS 9/S Q5 g ) )rsrrr rruru)rrvrtrvrr )every)rrtrN)r r rQoutlinerrs r test_outlineMaskTypeTest.test_outlines KK ! b) 1 xj1 1 2 3 1  IIKK  +-KLrc /SQnUHn[R"U5nUHn[R"U5nURU5nURU[RR5 SHNnUR UR 5UUR 5UUR 5U-S- 5 MP M M g)N)rk)rr)rrrrjr)r r convolverxr!rQr)ryr6s1rcs2rdors rtest_convolve__size MaskTypeTest.test_convolve__sizes8BRB[[_KKO%%a)9)9:A$$ Qq)9BKKM!/ 1::a=1  mV[[-=-=>/rcv[S5n[R"S5nURS5 [R"S5n[R"S5nUR X#5 UR US5 UR U[RR5 [XU5 UR5 UR5 UR X#[SS5S9 UR US5 UR U[RR5 [XU5 g ) zGchecks that convolution modifies only the correct portion of the outputrr r r/rrkr)r>outputr/rvN) rr r rr|rrxr!rfrr)ryrrrtests rtest_convolve__with_output'MaskTypeTest.test_convolve__with_outputs  ! KK   KK !{{8$ 1 !V a!1!12&    WR_ = !X a!1!12&rc[R"SSS9nSnUHbup4URUSU5nURU[RR5 UR UR 5U5 Md g)NrTr))rrr)rr r))rrr))rr)r r r|rxr!rQra)ryfullpts_dataptrzrs rtest_convolve__out_of_range(MaskTypeTest.test_convolve__out_of_rangesi{{6-K"* B MM$b9M  ! !-1A1A B   ]002N C #+rc [S5n[S5nURU5nURU[RR 5 [ UR5S5Hdn[ UR5S5HAnURURXE45S:HURX$S- US- 45SL5 MC Mf g)z#Tests the definition of convolutionrrrcN) rr|rxr r!r r rrQrr.)ryrcrdconvrrs r test_convolveMaskTypeTest.test_convolves $  ${{2 dFKK$4$45t}}q)*A4==?1-.  KK'1,bjj"fa"f=M.NRV.V/+rc[RRX"4SS9nURUS-US-4S5 U(a#UR XS5 UR 5 U$UR XS5 U$)NTrr r)r r!r rrrr)ryr!rrWinversepatterns r_draw_component_pattern_box(MaskTypeTest._draw_component_pattern_boxsm ++""D.ks<841QWWYY8s!N)r r!r rappendrrrasumconnected_componentrxrQrrb)ryr9r:r{rpatternsr/rrexpected_patternexpected_offsetrzrr!s rtest_connected_component%MaskTypeTest.test_connected_componentSs   ((7 006J)*,"33MP)*1*fk*22=!VL)*,4RL))//1<8<<002 dFKK$4$45 ~6 -8    . @. ,,.? //1=A'OG   **7;W]]_  (rcSn[RRUSS9nUR5nUR 5nUR U[RR5 UR UR5U5 UR UR5U5 UR UR5U5 UR UR5U5 g)zSEnsure a mask's connected component is correctly calculated when the mask is full. )rvrTrNr r!r rarrxrQr)ryr{rrzr!s r#test_connected_component__full_mask0MaskTypeTest.test_connected_component__full_masks!  ((T(B &,,.002 dFKK$4$45 ~6 -8 ,,.? //1=ArcSn[RRU5nUR5nSnUR 5nUR U[RR5 UR UR5U5 UR UR5U5 UR UR5U5 UR UR5U5 g)zTEnsure a mask's connected component is correctly calculated when the mask is empty. )rrrNr)ryr{rrrzr!s r$test_connected_component__empty_mask1MaskTypeTest.test_connected_component__empty_masks!  ((7 &,,.002 dFKK$4$45 ~6 -8 ,,.? //1=ArcSupX4n[RRUSS9nUS-US-peXV4nUS- US- 4nURUSUSS9n Sn UR 5n UR U5n UR U [RR5 URU R 5U 5 URU R5U5 URU RX5U 5 URUR 5U 5 URUR5U5 URURX5U 5 g) zEnsure a mask's connected component is correctly calculated when the coordinate's bit is set with a connected component of 1 bit. )rrKTrr rr)rN) r r!r rrarrxrQrrb) ryr9r:r{rxsetysetrOrrrzrr!s r%test_connected_component__one_set_bit2MaskTypeTest.test_connected_component__one_set_bitsR   ((T(B aZ1d,!8TAX. ;; 1ot< &,,.009 dFKK$4$45 ~6 -8    . @. ,,.? //1=A   & &'7 I  rczSn[RRU5nSup4S=nupgUS- US- 4n[RRX44SS9n [SU5H9n [SU5H&n XU S- US- 4;dMU R X4S 5 M( M; U R 5n UR X5 URU5n URU [RR5 URU R 5U 5 URU R5U5 URU RX5U 5 URUR 5U 5 URUR5U5 URURX5U 5 g ) zEnsure a mask's connected component is correctly calculated when the coordinate's bit is set with a connected component of > 1 bit. )qrKr)rur"rTrrrrN) r r!r r rrarrrxrQrrb)ryr{rp_widthp_heightrOrrrrrrrzr!s r(test_connected_component__multi_set_bits5MaskTypeTest.test_connected_component__multi_set_bitss"  ((7 "%%*$!8TAX.!;;++W,?d+Kq(#A1g&AE7Q;//$++QFA6'$ *//1+=009 dFKK$4$45 ~6 -8    . @. ,,.? //1=A   & &'7 I  rcbSupX4n[RRUSS9nUS-US-4nURUS5 UR 5nSnUR U5nUR U[RR5 URUR 5U5 URUR5U5 URUR 5U5 URUR5U5 URURU5S5 g)z`Ensure a mask's connected component is correctly calculated when the coordinate's bit is unset. )mrTrr rN) r r!r rrarrxrQrr) ryr9r:r{rrErrzr!s r#test_connected_component__unset_bit0MaskTypeTest.test_connected_component__unset_bits!   ((T(B aZ1- Y*&,,.00; dFKK$4$45 ~6 -8 ,,.? //1=A --i8! ss  {{ *33B7 _= z2 )4rc^Sn[RRUSS9nUR5nSnUR S5nUR [ U5U5 [XSU5 UR UR5U5 UR UR5U5 g)zEnsures connected_components() properly handles negative min values when the mask is full. Negative and zero values for the min parameter (minimum number of bits per connected component) equate to setting it to one. )rruTrrrrN) r r!r rarrQrrfr)ryrYr!rZ expected_lenrs r6test_connected_components__negative_min_with_full_maskCMaskTypeTest.test_connected_components__negative_min_with_full_maskR s {{ 5ZZ\  33B7 _-|<a0$7 z2 )4rcSn[RRU5n0n[U5HHnUR U5 [RRU5nUR U5 XSU'MJ USS-USS-4nUR U5 [RRU5nUR U5 XSU'UR 5nUR S5nUR[U5[U55 UHdn Sn [UR55H-n U RU 5(dMSn [X X;5 X; O URU SW 35 Mf URUR 5U5 URUR5U5 g ) zEnsures connected_components() properly handles negative min values when the mask has some bits set. Negative and zero values for the min parameter (minimum number of bits per connected component) equate to setting it to one. )rrurr rrFTzmissing component for pt=N)r r!r r=rrarrQrtuplekeysrrf assertTruer) ryrYr!rrnew_maskrrZrrfoundrs r:test_connected_components__negative_min_with_some_bits_setGMaskTypeTest.test_connected_components__negative_min_with_some_bits_setg s {{ *dmF KK {{'' 2H OOF #%-6 " $A,!#Yq\Q%67 F;;##I.!)vZZ\ 33B7 _-s>/BC#DEN//12;;r?? E#D0BC&* 3 OOE%>rd#C D$ z2 )4rc0/nURS5 URS5 URS5 URS5 URS5 URS5 UHup#/n[R"U5nUH7nUR[U55 UHnUR U5 M M9 [ U[ S9nUR5nUR[ UR5[ S9USU35 M g ) z+Ensures get_bounding_rects works correctly.)r))r/rlrj)r))rr)rr ))r/rlrjrkr rrr)r^)))r rrkrrr)r^))rrrr)r))rrrrjrkrr)r^))r/)r)r)r)r)r"rN) rr r r-rsortedrget_bounding_rectsr) ry mask_datarrect_point_tuplesrectsr! rect_pointsrexpected_rectss rtest_get_bounding_rects$MaskTypeTest.test_get_bounding_rects s#                    (1 #DE;;t$D0  1+>?%BKKO& 1 $Eu5N++-E  t..0e<v (1rc@SnSn[R"U[S5n[R"S5n[R"S5S4[R"S5S44nUHupgUR U5 [R R X'S 9nURU5n URX5 [(d&UR[R"U 5U5 URU R5U5 [X U5 M g ) z8Ensures empty and full masks can be drawn onto surfaces.rrrrredwhiteTblackFrN)r r_SRCALPHAColorrr!r to_surfaceassertIsIS_PYPYrQsys getrefcountrrX) ryexpected_ref_countrr surface_color test_fillsrTrr!rs rtest_to_surfaceMaskTypeTest.test_to_surface s..x4 U+ ||G,d3fll76KU5ST $. N LL ';;##D#4D1J MM* .7  !<>PQ   Z002D 9 . A%/rcSn[nSnSn[R"S5S4[R"S5S44nUGHupg[RR XGS9nS Hn U (aUR S 5n OUR 5n UR U [R5 [(d&UR[R"U 5U5 URU R5U-5 URU R5U5 URU R5U5 [!X U5 M GM g ) zAEnsures empty and full masks can be drawn onto a created surface.r rrrTrFrrNrr rr!r rrxr_rrQr r r get_flags get_bitsizerrX) ryr  expected_flagexpected_depthrr rTrr!use_argrs rtest_to_surface__create_surface,MaskTypeTest.test_to_surface__create_surface( s ||G,d3fll76KU5ST $. N;;##D#4D(!%!6J!%!2J%%j&..Aw$$S__Z%@BTU 4 4 6 FG  !7!7!9>J  !4!4!6=#DnE)%/rc@Sn[R"S5n[R"S5nSn[RRUSS9n[R"U5nSU0nSHnUR U5 U(aUR "S 0UD6n OUR US5n URX5 [(d&UR[R"U 5U5 URU R5U5 [X U5 M g ) z/Ensures to_surface accepts a surface arg/kwarg.rrrr^TrrrNr2)r rr!r r_rrrrrQr r rrX) ryr rTr rr!rr use_kwargsrs rtest_to_surface__surface_param+MaskTypeTest.test_to_surface__surface_paramA sg. U+ {{40..&W%'J LL '!__6v6 !__VI->? MM* .7  !<>PQ   Z002D 9 . A(rcSn[nSn[R"S5nSn[RR USS9n[R "XRU5nUR U5 SU0nSHn U (aUR"S 0UD6n OURS US5n URU [R 5 [(d&UR[R"U 5U5 URU R5U-5 URU R5U5 URU R!5U5 [#X U5 M g ) z2Ensures to_surface accepts a setsurface arg/kwarg.r rrr^Tr setsurfacerNr2rr rr!r r_rrrxrrQr r rrrrrX) ryr rrrTrr!rrrrs r!test_to_surface__setsurface_param.MaskTypeTest.test_to_surface__setsurface_paramY s  e,{{40^^DH ' +'J!__6v6 !__T6,3GH  ! !*fnn =7  !<>PQ OOJ002]B C   Z335~ F   Z002D 9 . A(rcSn[nSn[R"S5nSn[RR U5n[R "XRU5nUR U5 SU0nSHn U (aUR"S0UD6n OURSSUS5n URU [R 5 [(d&UR[R"U 5U5 URU R5U-5 URU R5U5 URU R!5U5 [#X U5 M g) z4Ensures to_surface accepts a unsetsurface arg/kwarg.r rrr^ unsetsurfacerNr2r) ryr rrrTrr!r#rrrs r#test_to_surface__unsetsurface_param0MaskTypeTest.test_to_surface__unsetsurface_paramt s e,{{%~~d>J .) ,/'J!__6v6 !__T49OP  ! !*fnn =7  !<>PQ OOJ002]B C   Z335~ F   Z002D 9 . A(rc~Sn[nSn[R"S5nSn[RR USS9nSU0nSHnU(aUR "S 0UD6n OUR S S S US5n UR U [R5 [(d&UR[R"U 5U5 URU R5U-5 URU R5U5 URU R5U5 [!X U5 M g ) z0Ensures to_surface accepts a setcolor arg/kwarg.r rrr^TrsetcolorrNr2r ryr rrrTrr!rrrs rtest_to_surface__setcolor_param,MaskTypeTest.test_to_surface__setcolor_param s e,{{40n-'J!__6v6 !__T4vj?QR  ! !*fnn =7  !<>PQ OOJ002]B C   Z335~ F   Z002D 9 . A(rc[R"S5nSn[RRUSS9nUR SSSSS9nUR UR 5U5 [XU5 g)z(Ensures the default setcolor is correct.rr$TrN)rrr# unsetcolorr rr!r rrQrrXryrTrr!rs r!test_to_surface__setcolor_default.MaskTypeTest.test_to_surface__setcolor_default sog.{{40__T%  ,,.5Dn=rc Sn[nSn[R"S5nSn[RR U5nSU0nSHnU(aUR "S0UD6n OUR SSSSUS5n UR U [R5 [(d&UR[R"U 5U5 URU R5U-5 URU R5U5 URU R5U5 [!X U5 M g) z2Ensures to_surface accepts a unsetcolor arg/kwarg.r rrr^r,rNr2rr(s r!test_to_surface__unsetcolor_param.MaskTypeTest.test_to_surface__unsetcolor_param s  e,{{%/'J!__6v6 !__$dF<,@   ! !*fnn =7  !<>PQ OOJ002]B C   Z335~ F   Z002D 9 . A(rc[R"S5nSn[RRU5nUR SSSSS9nUR UR 5U5 [XU5 g)z*Ensures the default unsetcolor is correct.rr$N)rrr#r'r-r.s r#test_to_surface__unsetcolor_default0MaskTypeTest.test_to_surface__unsetcolor_default sjg.{{%__Tt%  ,,.5Dn=rc Sn[nSnSn[R"S5nSnSn[RR U5nSU0n SHn U (aUn UR "S 0U D6n OUn UR S S S S S U S5n UR U [R5 [(d&UR[R"U 5U5 URU R5U-5 URU R5U5 URU R5U5 [!X U 5 M g ) z,Ensures to_surface accepts a dest arg/kwarg.r rrrrrrr/r^destrNr2r) ryr rrdefault_surface_colordefault_unsetcolorr9rr!rrrTrs rtest_to_surface__dest_param(MaskTypeTest.test_to_surface__dest_param s   ,#\\'2{{%$'J!3!__6v6 !6!__$dD&.   ! !*fnn =7  !<>PQ OOJ002]B C   Z335~ F   Z002D 9 . A%(rc[R"S5n[R"S5nSn[RRUSS9nUR 5nUSS-USS-4n[R "U[ S 5nURU5 URUS S S S 9nURX5 URUR5U5 [XX5 [XX%5 g ) z$Ensures the default dest is correct.rrrTrrr rrNrr#r,r rr!r rOr_rrrrrQrrXr^ ryrTr rYr!rZ surf_sizerrs rtest_to_surface__dest_default*MaskTypeTest.test_to_surface__dest_default sg. U+  {{ 5MMO q\A%y|a'78 ..Hb9 ]#__ 4D%  j* ,,. :DnH%d Qrc Sn[nSnSn[R"S5nSn[RR U5nSUR 50nSHn U (aUn UR "S 0UD6n OUn UR SSSSSS US5n URU [R5 [(d&UR[R"U 5U5 URU R5U-5 URU R5U5 URU R!5U5 [#X U 5 M g) z-Ensures to_surface accepts an area arg/kwarg.r rr8rr^arearNr/r2)rr rr!r rOrrxr_rrQr r rrrrrX) ryr rrr:r;rr!rrrTrs rtest_to_surface__area_param(MaskTypeTest.test_to_surface__area_param s&  ,#\\'2{{%$--/*'J!3!__6v6 !6!__$dD&&.   ! !*fnn =7  !<>PQ OOJ002]B C   Z335~ F   Z002D 9 . A%(rc[R"S5n[R"S5nSn[RRUSS9nUR 5nUSS-USS-4n[R "U[ S 5nURU5 URUS S S S 9nURX5 URUR5U5 [XX5 [XX%5 g ) z$Ensures the default area is correct.rrrTrrr rrNr?r@rAs rtest_to_surface__area_default*MaskTypeTest.test_to_surface__area_default1 sg. U+  {{ 5MMO q\A%y|a'78 ..Hb9 ]#__ 4D%  j* ,,. :DnH%d Qrc`[R"S5nSn[RRUSS9n[R"U5n[R"S5nUR 5nUR U5 SSS[R"S 54S U4S UR 54S U4S U44n[U5nUHeupURU 5 UR U5 UR"S0UD6n URU R5U5 [X U5 Mg g)z.Ensures to_surface accepts the correct kwargs.rr^TrrNNr9r/r,yellowr'r#rrNr2) r rr!r r_rrdictpoprrQrrX) ryrTrr!rr r test_datarnamerrs rtest_to_surface__kwargs$MaskTypeTest.test_to_surface__kwargsI s g.{{40..& U+ \\^ '   6<<1 2  ( W\\^ , : &   i GD JJt  LL '262J   Z002D 9 . A!rc[R"S5nSn[RRU5n[R"U[ S5n[R"S5nUR U5 UR5nUR U5 SSSU4S[R"S 54S U4S U4S 4n[U5nUHtupURU 5 UR"S0UD6n URU [R5 URU R5U5 [X U5 Mv g )zGEnsures to_surface accepts the correct kwargs when creating a surface. rr^rrrMrNr,r'rOr#r)rNNr2)r rr!r r_rrrrPrQrrxrQrrX) ryrTrr!rsetsurface_colorr#rRrrSrrs r&test_to_surface__kwargs_create_surface3MaskTypeTest.test_to_surface__kwargs_create_surfaceh s g.{{%^^D(B7 !<<.()!( .)   > * h/ 0 \ * : &  i GD JJt 262J  ! !*fnn =   Z002D 9 . A!rc f[R"S5nSn[RRUSS9n[R"U5nUR SUSU[R"U5SS9nUR XT5 URUR5U5 [XU5 g)z2Ensures to_surface kwargs are not order dependent.bluerTrr/N)r9r'r,rr#r) r rr!r r_rrrQrrXryrTrr!rrs r)test_to_surface__kwargs_order_independent6MaskTypeTest.test_to_surface__kwargs_order_independent sf-{{40..&__#- %  j* ,,.5Dn=rc Sn[RRUSS9n[R"S5n[R"U5nUR [ 5 URSSSSSS5 SSS5 UR [ 5 URSSSSU5 SSS5 UR [ 5 URSSSUS5 SSS5 UR [ 5 URSSUSS5 SSS5 UR [ 5 URSUSSS5 SSS5 UR [ 5 URUSSSS5 SSS5 g!,(df  GN=f!,(df  N=f!,(df  N=f!,(df  N=f!,(df  N=f!,(df  g=f)/Ensures to_surface detects invalid kwarg types.rTrgreenNr)r r!r rr_rrr)ryrr! invalid_surf invalid_colors r#test_to_surface__args_invalid_types0MaskTypeTest.test_to_surface__args_invalid_types sk{{40||G, t,   y ) OOD$dD$ ?*  y ) OOD$dM B*  y ) OOD$mT B*  y ) OOD$ dD A*  y ) OOD,dD A*  y ) OOL$dD A* ))* )* )* )* )* )* )sH"FF F$<F5/G"G F F!$ F25 G G G%cfSn[RRU5n[R"U5[R"U5[R"U5[R"S5[R"S5SS.nS[R"S5S[R"S5[R"S5S S.nSnUHDn[ U5nXFXv'UR [5 UR"S 0UD6 S S S 5 MF g !,(df  MX=f) r`rrar/rrr#r'r,r9)rr rr)rrrrrrrNr2) r r!r r_rrPrrr)ryrr! valid_kwargsinvalid_kwargs kwarg_orderkwargrs r%test_to_surface__kwargs_invalid_types2MaskTypeTest.test_to_surface__kwargs_invalid_types s{{%~~d+ ..."NN40 W- ,,w/  $ ,,w/, F+ ..0   !E,'F*1FM""9-)&).- !.-s D!! D0 c[RRS5nS[R"S50nUR [ 5 UR "S0UD6 SSS5 g!,(df  g=f)z/Ensures to_surface detects invalid kwarg names.r setcolourrNr2)r r!r rrrr)ryr!rs r$test_to_surface__kwargs_invalid_name1MaskTypeTest.test_to_surface__kwargs_invalid_name sR{{'v||E23   y ) OO %f %* ) )s A)) A7cSn[R"S5n[R"S5n[R"S5n[R"S5n[R"S5n[R"U[S5nUR 5nUR 5n UR U5 U R U5 [R RUSS 9n Un S S U4S U4S U 4SU4SU4S4n /n [U 5nU H[unnUbU RU5 URU5 UR U5 U R"U 0UD6n[UUU 5 M] g)z7Ensures to_surface accepts a combination of args/kwargsr^rrOr[racyanrTrrMrrr#r'r,rNN) r rr_rrrr!r rPrrQrrX)ryrr rWunsetsurface_colorr'r,rrr#r!rTrRargsrrSrrs r test_to_surface__args_and_kwargs-MaskTypeTest.test_to_surface__args_and_kwargs sQ U+ !<<1#\\&1<<(\\&) ..x4\\^ ||~ (),-{{40)   : & \ *  " : &  i%KD% E" JJt  LL '$9&9J j. A%rc Sn[RRUSS9n[R"U[S5n[R "S5nSSUR U5USSS 4nUHnURUS 9n[XU5 M g ) zEnsures to_surface handles valid unsetcolor formats correctly.r^rrar{r}r~rr,Nr)ryrr!rrTrr,rs r)test_to_surface__valid_unsetcolor_formats6MaskTypeTest.test_to_surface__valid_unsetcolor_formats- s{{%..x4g.   OON +     &JJ?J . A&rc[RRS5nSH0nUR[5 UR US9 SSS5 M2 [R "S5[R"S5S4H0nUR[5 UR US9 SSS5 M2 g!,(df  M=f!,(df  MV=f)z>Ensures to_surface handles invalid setcolor formats correctly.r^z green colorz #00FF00FF0 0x00FF00FF0rrNrr皙?r r!r rrrr_r)ryr!r's r)test_to_surface__invalid_setcolor_formats6MaskTypeTest.test_to_surface__invalid_setcolor_formatsB s{{'LH"":.2/.M /V1DcJH""9-2.-K/..-B8C 8 C C c[RRS5nSH0nUR[5 UR US9 SSS5 M2 [R "S5[R"S5S4H0nUR[5 UR US9 SSS5 M2 g!,(df  M=f!,(df  MV=f)z@Ensures to_surface handles invalid unsetcolor formats correctly.r^rrNrrrr)ryr!r,s r+test_to_surface__invalid_unsetcolor_formats8MaskTypeTest.test_to_surface__invalid_unsetcolor_formatsN s{{'NJ"":.:6/.O">>&16;;v3FLJ""9-:6.-M/..-rc[R"S5n[RRSSS9nSSS/[ SS5S[R "SS54nUHnUR US 9n[XU5 M g ) z8Ensures to_surface handles valid dest formats correctly.rr|Trr/r)rrrrrr9N)r rr!r rr'rrXryrTr!destsr9rs r#test_to_surface__valid_dest_formats0MaskTypeTest.test_to_surface__valid_dest_formatsZ szg.{{T2  F AqM  KK )  Dd3J . Arc[RRS5nSSSS1SS0[4nUH0nUR [ 5 UR US9 SSS5 M2 g!,(df  MD=f)z:Ensures to_surface handles invalid dest formats correctly.r|rbrirrrN)r r!r r'rrr)ryr! invalid_destsr9s r%test_to_surface__invalid_dest_formats2MaskTypeTest.test_to_surface__invalid_dest_formatsk sk{{'   F F   "D""9-T*.-"--s A&& A5 c<[R"S5n[RRSSS9n[R"SS5[R"SS5[R"SS54nUHnUR US 9n[ XU5 M g ) z?Ensures to_surface correctly handles negative sized dest rects.rr|Trr/)r)rr)rrrNr rr!r r'rrXrs r)test_to_surface__negative_sized_dest_rect6MaskTypeTest.test_to_surface__negative_sized_dest_rectz sg.{{T2 KK * KK * KK +  Dd3J . Arc<[R"S5n[RRSSS9n[R"SS5[R"SS5[R"SS54nUHnUR US9n[ XU5 M g ) z;Ensures to_surface correctly handles zero sized dest rects.rr|Trr/rrrNrrs r%test_to_surface__zero_sized_dest_rect2MaskTypeTest.test_to_surface__zero_sized_dest_rect sg.{{T2 KK ( KK ( KK '  Dd3J . ArcSn[R"S5n[R"S5n[R"U5n[RR USS9nSnSnUSUS USUS 4Xg4U[ U54[ U5U4[ U5[ U54USUS USUS /Xg/U[ U5/[ U5U/[ U5[ U5/[R "Xg54 nUHQn URU5 [R "U 5n URXIS 9n [X X:5 [X X*5 MS g ) z8Ensures to_surface handles valid area formats correctly.r|rrTrr/rrrrFN) r rr_r!r listr'rrrXr^) ryrr rTrr!area_pos area_sizeareasrFrUrs r#test_to_surface__valid_area_formats0MaskTypeTest.test_to_surface__valid_area_formats sG U+ g...&{{40 a[(1+y|Yq\ B  ! tI ' (^Y ' (^T)_ - a[(1+y|Yq\ B  ! tI ' (^Y ' (^T)_ - KK ,  D LL ' D)Irrr rrrrzinvalid area argumentrN)r r!r r'assertRaisesRegexrr)ryr! invalid_areasrFunused_to_surfaces r%test_to_surface__invalid_area_formats2MaskTypeTest.test_to_surface__invalid_area_formats sy{{'      aL   "D'' 3JK$(OOO$>!LK"KKs A++ A: cSn[R"S5n[R"S5n[R"U5n[RR U5nUR S5 [R "SS5[R "SS5[R "S S 54nUH;nURU5 URXGS 9n[XX75 [XX'5 M= g ) z?Ensures to_surface correctly handles negative sized area rects.r|rrr/rjrmrlrrrkrprN) r rr_r!r rr'rrrXr^) ryrr rTrr!rrFrs r)test_to_surface__negative_sized_area_rect6MaskTypeTest.test_to_surface__negative_sized_area_rect s U+ g...&{{% F KK ( KK ( KK )  D LL '&-?F>*+3T*:-;z*1;T0B,3CF<0/3Tl #-#5$*JJvt$<5?F6N#''7'C9I)7)C9A9N'9'E9K)9)E9C9N-1__-Fv-F $ 5 5j&.. Q'.w$($4$4(+ (CEW%&!% 0D0D0F0V W $ 0 0$.$:$:$&-?F>*+3T*:-;z*1;T0B,3CF<0#LL7/3Tl #-#5$*JJvt$<5?F6N#''7'C9I)7)C9A9F'9'E9K)9)E9C9F-1__-Fv-F $ j' B'.w$($4$4(+ (CEW%&!% 0D0D0F0V W $ 0 0$.$:$:$# UH n[US-TS5Ho!U4v M M" g7frr Nr/r3rrr:s rr7CMaskTypeTest.test_to_surface__set_and_unset_bits.. )RLq%Avq:QQF:QFL(+rc3P># UHn[T5Ho!U4v M M g7frGr/rs rr7r L 1eFmAm r2rrN)r rr!r rOr_r rr?rrrrPr\rrQrR)rydefault_setcolorr;r9rr!rZrr rWr9rmask_posrTr:s @r#test_to_surface__set_and_unset_bits0MaskTypeTest.test_to_surface__set_and_unset_bits sb"<<0#\\'2'' v{{%MMO ..& U+ SE%LRC KK S''D $  LL '? --c22%2N[[**%5N%7N  !2!23!7PSUM    #(rc ^S=unmn[RRU5nUR5n[R"U5n[R "S5nUR 5n[R "S5nURU5 UR 5n [R "S5n U RU 5 U4Sj[U55Hn URU 5 M URHn Xl SHn URU5 U (aURUU UU SSS9nOURUU UU S 9nUR5 U4S j[U55Hnn U S U S - U S U S - 4nURU 5(dUnOURU5(aUnOU nUR!URU 5U5 Mp UR#5 M M g) ziEnsures that to_surface works correctly with with set/unset bits when using setsurface and unsetsurface. rrrar[c3Z># UH n[US-TS5Ho!U4v M M" g7frr/rs rr7`MaskTypeTest.test_to_surface__set_and_unset_bits_with_setsurface_unsetsurface.. rrrN)r9rr#r'r,)r9rr#c3P># UHn[T5Ho!U4v M M g7frGr/rs rr7r sPLq%-QF-FLr2rr)r r!r rOr_rrrr rr?rrrPr\rrQrR)ryr9rr!rZrr rrWr#rvrWr9disable_color_paramsrrrTr:s @r@test_to_surface__set_and_unset_bits_with_setsurface_unsetsurfaceMMaskTypeTest.test_to_surface__set_and_unset_bits_with_setsurface_unsetsurface s (' v{{%MMO ..& U+ \\^ !<<0()||~ #\\&1,-SE%LRC KK S''D $  )6$ ]+'!%!#-%1!%#' "1"J"&!#-%1 "1"J!PE%LPC #Aa 0#a&472BCH$11#66)6X..)9);$$Z%6%6s%;^LQ!!#C)6 (rc[R"S5n[R"S5nSnSn[R"U5n[R"S5nSHn[RR X7S9nUR U5 U(aUOUn UR U5n URX5 URU R5U5 [X U 5 M g) zEnsures that surfaces narrower than the mask work correctly. For this test the surface's width is less than the mask's width. rrrrsrrrN r rr_r!r rrrrQrrX) ryrr;rY narrow_sizerr rr!rTrs r+test_to_surface__surface_narrower_than_mask8MaskTypeTest.test_to_surface__surface_narrower_than_mask s "<<0#\\'2  ..- U+ !D;;##I#9D LL '15-;MN1J MM* .   Z002K @ . A"rcN[R"S5n[R"S5nSnSn[R"U[S5n[R"S5nUR U5 UR 5nSHn[R RX8S9n U RUS 9n URU [R5 URU R5U5 U(a[X Xg5 [X X5 M[X U5 M g ) zEnsures that setsurfaces narrower than the mask work correctly. For this test the setsurface's width is less than the mask's width. rrrrrrrrrNr rr_rrrOr!r rrxrQrrXr^) ryrr;rYrrrWsetsurface_rectrr!rs r.test_to_surface__setsurface_narrower_than_mask;MaskTypeTest.test_to_surface__setsurface_narrower_than_mask$s "<<0#\\'2  ^^K2> !<<.()$--/!D;;##I#9DJ?J  ! !*fnn =   Z002I >#D6FX-&6$D6HI"rcN[R"S5n[R"S5nSnSn[R"U[S5n[R"S5nUR U5 UR 5nSHn[R RX8S9n U RUS 9n URU [R5 URU R5U5 U(a[X U5 M[X Xg5 [X X'5 M g ) zEnsures that unsetsurfaces narrower than the mask work correctly. For this test the unsetsurface's width is less than the mask's width. rrrrrrrrr#Nr) ryrr;rYrr#rvunsetsurface_rectrr!rs r0test_to_surface__unsetsurface_narrower_than_mask=MaskTypeTest.test_to_surface__unsetsurface_narrower_than_maskDs "<<0#\\'2  ~~k8R@ #\\%0,-(113!D;;##I#9DlCJ  ! !*fnn =   Z002I >#D6FG#&8.&8"rcSnSnSn[R"U[S5n[R"S5nUR U5 UR 5nSHn[R RX'S9nURUSSS 9n URU [R5 URU R5U5 U(a[X XV5 [X X5 M[X U5 M g) zEnsures that setsurfaces narrower than the mask work correctly when setcolor and unsetcolor are set to None. For this test the setsurface's width is less than the mask's width. r8rrrrrrNrr'r,r r_rrrrOr!r rrxrQrrXr^) ryr:rYrrrWrrr!rs r>test_to_surface__setsurface_narrower_than_mask_and_colors_noneKMaskTypeTest.test_to_surface__setsurface_narrower_than_mask_and_colors_nonefs !-  ^^K2> !<<.()$--/!D;;##I#9D%)J  ! !*fnn =   Z002I >#D6FX-&;$D6KL#"rcSnSnSn[R"U[S5n[R"S5nUR U5 UR 5nSHn[R RX'S9nURUSSS 9n URU [R5 URU R5U5 U(a[X U5 M[X XV5 [X X5 M g) zEnsures that unsetsurfaces narrower than the mask work correctly when setcolor and unsetcolor are set to None. For this test the unsetsurface's width is less than the mask's width. r8rrrrrrNr#r'r,r) ryr:rYrr#rvrrr!rs r@test_to_surface__unsetsurface_narrower_than_mask_and_colors_noneMMaskTypeTest.test_to_surface__unsetsurface_narrower_than_mask_and_colors_nones !-  ~~k8R@ #\\%0,-(113!D;;##I#9D)DT)J  ! !*fnn =   Z002I >#D6KL#&8.&;#"rc[R"S5n[R"S5nSnSn[R"U5n[R"S5nSHn[RR X7S9nUR 5n UR U5 U(aUOUn URU5n URX5 URU R5U5 [X X5 [X Xi5 M g) zEnsures that surfaces wider than the mask work correctly. For this test the surface's width is greater than the mask's width. rrrrurrrrN r rr_r!r rOrrrrQrrXr^) ryrr;rY wide_sizerr rr!rZrTrs r(test_to_surface__surface_wider_than_mask5MaskTypeTest.test_to_surface__surface_wider_than_mask "<<0#\\'2  ..+ U+ !D;;##I#9D I LL '15-;MN1J MM* .   Z002I > . L )$M U"rc[R"S5nSnSn[R"U[S5n[R"S5nUR U5 SHn[R R X&S9nU(aUOUnURUS9n URU [R5 URU R5U5 [X U5 M g ) zEnsures that setsurfaces wider than the mask work correctly. For this test the setsurface's width is greater than the mask's width. rrrrrrrrN r rr_rrr!r rrxrQrrX) ryr;rYrrrWrr!rTrs r+test_to_surface__setsurface_wider_than_mask8MaskTypeTest.test_to_surface__setsurface_wider_than_masks $\\'2  ^^Ix< !<<.()!D;;##I#9D15-;MNJ?J  ! !*fnn =   Z002I > . A"rc[R"S5nSnSn[R"U[S5n[R"S5nUR U5 SHn[R R X&S9nU(aUOUnURUS9n URU [R5 URU R5U5 [X U5 M g ) zEnsures that unsetsurfaces wider than the mask work correctly. For this test the unsetsurface's width is greater than the mask's width. rrrrrrrrNr) ryrrYrr#rvrr!rTrs r-test_to_surface__unsetsurface_wider_than_mask:MaskTypeTest.test_to_surface__unsetsurface_wider_than_mask "<<0  ~~i2> #\\%0,-!D;;##I#9D15-;MNlCJ  ! !*fnn =   Z002I > . A"rc[R"S5n[R"S5nSnSn[R"U5n[R"S5nSHn[RR X7S9nUR U5 U(aUOUn UR U5n URX5 URU R5U5 [X U 5 M g) zEnsures that surfaces shorter than the mask work correctly. For this test the surface's height is less than the mask's height. rrrrurrrrrNr) ryrr;rY short_sizerr rr!rTrs r*test_to_surface__surface_shorter_than_mask7MaskTypeTest.test_to_surface__surface_shorter_than_masks "<<0#\\'2  .., U+ !D;;##I#9D LL '15-;MN1J MM* .   Z002J ? . A"rcN[R"S5n[R"S5nSnSn[R"U[S5n[R"S5nUR U5 UR 5nSHn[R RX8S9n U RUS 9n URU [R5 URU R5U5 U(a[X Xg5 [X X5 M[X U5 M g ) zEnsures that setsurfaces shorter than the mask work correctly. For this test the setsurface's height is less than the mask's height. rrrr rrrrrNr) ryrr;rYr rrWrrr!rs r-test_to_surface__setsurface_shorter_than_mask:MaskTypeTest.test_to_surface__setsurface_shorter_than_mask s "<<0#\\'2  ^^J"= !<<.()$--/!D;;##I#9DJ?J  ! !*fnn =   Z002I >#D6FX-&6$D6HI"rcN[R"S5n[R"S5nSnSn[R"U[S5n[R"S5nUR U5 UR 5nSHn[R RX8S9n U RUS 9n URU [R5 URU R5U5 U(a[X U5 M[X Xg5 [X X'5 M g ) zEnsures that unsetsurfaces shorter than the mask work correctly. For this test the unsetsurface's height is less than the mask's height. rrrr rrrrrNr) ryrr;rYr r#rvrrr!rs r/test_to_surface__unsetsurface_shorter_than_mask#D6FG#&8.&8"rcSnSnSn[R"U[S5n[R"S5nUR U5 UR 5nSHn[R RX'S9nURUSSS 9n URU [R5 URU R5U5 U(a[X XV5 [X X5 M[X U5 M g) zEnsures that setsurfaces shorter than the mask work correctly when setcolor and unsetcolor are set to None. For this test the setsurface's height is less than the mask's height. r8rr rrrrNrr) ryr:rYr rrWrrr!rs r=test_to_surface__setsurface_shorter_than_mask_and_colors_noneJMaskTypeTest.test_to_surface__setsurface_shorter_than_mask_and_colors_noneOs !-  ^^J"= !<<.()$--/!D;;##I#9D%)J  ! !*fnn =   Z002I >#D6FX-&;$D6KL#"rcSnSnSn[R"U[S5n[R"S5nUR U5 UR 5nSHn[R RX'S9nURUSSS 9n URU [R5 URU R5U5 U(a[X U5 M[X XV5 [X X5 M g) zEnsures that unsetsurfaces shorter than the mask work correctly when setcolor and unsetcolor are set to None. For this test the unsetsurface's height is less than the mask's height. r8rr rrrrNrr) ryr:rYr r#rvrrr!rs r?test_to_surface__unsetsurface_shorter_than_mask_and_colors_noneLMaskTypeTest.test_to_surface__unsetsurface_shorter_than_mask_and_colors_noneqs !-  ~~j(B? #\\%0,-(113!D;;##I#9D)DT)J  ! !*fnn =   Z002I >#D6KL#&8.&;#"rc[R"S5n[R"S5nSnSn[R"U5n[R"S5nSHn[RR X7S9nUR 5n UR U5 U(aUOUn URU5n URX5 URU R5U5 [X X5 [X Xi5 M g) zEnsures that surfaces taller than the mask work correctly. For this test the surface's height is greater than the mask's height. rrr rrrrNr) ryrr;rY tall_sizerr rr!rZrTrs r)test_to_surface__surface_taller_than_mask6MaskTypeTest.test_to_surface__surface_taller_than_maskrrc[R"S5nSnSn[R"U[S5n[R"S5nUR U5 SHn[R R X&S9nU(aUOUnURUS9n URU [R5 URU R5U5 [X U5 M g ) zEnsures that setsurfaces taller than the mask work correctly. For this test the setsurface's height is greater than the mask's height. rr rrrrrrNr) ryr;rYrrrWrr!rTrs r,test_to_surface__setsurface_taller_than_mask9MaskTypeTest.test_to_surface__setsurface_taller_than_masks $\\'2  ^^Ix< !<<.()!D;;##I#9D15-;MNJ?J  ! !*fnn =   Z002I > . A"rc[R"S5nSnSn[R"U[S5n[R"S5nUR U5 SHn[R R X&S9nU(aUOUnURUS9n URU [R5 URU R5U5 [X U5 M g ) zEnsures that unsetsurfaces taller than the mask work correctly. For this test the unsetsurface's height is greater than the mask's height. rr rrrrrrNr) ryrrYrr#rvrr!rTrs r.test_to_surface__unsetsurface_taller_than_mask;MaskTypeTest.test_to_surface__unsetsurface_taller_than_maskrrc[R"S5n[R"S5nSnSn[R"U5n[R"S5nSHn[RR X7S9nUR 5n UR U5 U(aUOUn URU5n URX5 URU R5U5 [X X5 [X Xi5 M g) zEnsures that surfaces wider and taller than the mask work correctly. For this test the surface's width is greater than the mask's width and the surface's height is greater than the mask's height. rrrrrrrNr) ryrr;rYwide_tall_sizerr rr!rZrTrs r3test_to_surface__surface_wider_and_taller_than_mask@MaskTypeTest.test_to_surface__surface_wider_and_taller_than_masks "<<0#\\'2 !..0 U+ !D;;##I#9D I LL '15-;MN1J MM* .   Z002N C . L )$M U"rc[R"S5nSnSn[R"U[S5n[R"S5nUR U5 SHn[R R X&S9nU(aUOUnURUS9n URU [R5 URU R5U5 [X U5 M g ) zEnsures that setsurfaces wider and taller than the mask work correctly. For this test the setsurface's width is greater than the mask's width and the setsurface's height is greater than the mask's height. rr$rrrrrrNr) ryr;rYr&rrWrr!rTrs r6test_to_surface__setsurface_wider_and_taller_than_maskCMaskTypeTest.test_to_surface__setsurface_wider_and_taller_than_masks$\\'2 !^^NHbA !<<.()!D;;##I#9D15-;MNJ?J  ! !*fnn =   Z002I > . A"rc[R"S5nSnSn[R"U[S5n[R"S5nUR U5 SHn[R R X&S9nU(aUOUnURUS9n URU [R5 URU R5U5 [X U5 M g ) zEnsures that unsetsurfaces wider and taller than the mask work correctly. For this test the unsetsurface's width is greater than the mask's width and the unsetsurface's height is greater than the mask's height. rr$rrrrrrNr) ryrrYr&r#rvrr!rTrs r8test_to_surface__unsetsurface_wider_and_taller_than_maskEMaskTypeTest.test_to_surface__unsetsurface_wider_and_taller_than_masks"<<0 !~~nhC #\\%0,-!D;;##I#9D15-;MNlCJ  ! !*fnn =   Z002I > . A"rc[R"S5n[R"S5nSnSn[R"U5n[R"S5nSHn[RR X7S9nUR 5n UR U5 U(aUOUn URU5n URX5 URU R5U5 [X X5 [X Xi5 M g) zEnsures that surfaces wider and shorter than the mask work correctly. For this test the surface's width is greater than the mask's width and the surface's height is less than the mask's height. rrr)rrrrrNr) ryrr;rYwide_short_sizerr rr!rZrTrs r4test_to_surface__surface_wider_and_shorter_than_maskAMaskTypeTest.test_to_surface__surface_wider_and_shorter_than_mask,s"<<0#\\'2 !..1 U+ !D;;##I#9D I LL '15-;MN1J MM* .   Z002O D . L )$M U"rcN[R"S5n[R"S5nSnSn[R"U[S5n[R"S5nUR U5 UR 5nSHn[R RX8S9n U RUS 9n URU [R5 URU R5U5 U(a[X Xg5 [X X5 M[X U5 M g ) zEnsures that setsurfaces wider and shorter than the mask work correctly. For this test the setsurface's width is greater than the mask's width and the setsurface's height is less than the mask's height. rrrr rrrrrNr) ryrr;rYr0rrWrrr!rs r7test_to_surface__setsurface_wider_and_shorter_than_maskDMaskTypeTest.test_to_surface__setsurface_wider_and_shorter_than_maskHs"<<0#\\'2 !^^OXrB !<<.()$--/!D;;##I#9DJ?J  ! !*fnn =   Z002I >#D6FX-&6$D6HI"rcN[R"S5n[R"S5nSnSn[R"U[S5n[R"S5nUR U5 UR 5nSHn[R RX8S9n U RUS 9n URU [R5 URU R5U5 U(a[X U5 M[X Xg5 [X X'5 M g ) zEnsures that unsetsurfaces wider and shorter than the mask work correctly. For this test the unsetsurface's width is greater than the mask's width and the unsetsurface's height is less than the mask's height. rrrr rrrrrNr) ryrr;rYr0r#rvrrr!rs r9test_to_surface__unsetsurface_wider_and_shorter_than_maskFMaskTypeTest.test_to_surface__unsetsurface_wider_and_shorter_than_maskjs"<<0#\\'2 !~~oxD #\\%0,-(113!D;;##I#9DlCJ  ! !*fnn =   Z002I >#D6FG#&8.&8"rc[R"S5n[R"S5nSnSn[R"U5n[R"S5nSHn[RR X7S9nUR 5n UR U5 U(aUOUn URU5n URX5 URU R5U5 [X X5 [X Xi5 M g) zEnsures that surfaces narrower and taller than the mask work correctly. For this test the surface's width is less than the mask's width and the surface's height is greater than the mask's height. rrrr%rrrrNr) ryrr;rYnarrow_tall_sizerr rr!rZrTrs r6test_to_surface__surface_narrower_and_taller_than_maskCMaskTypeTest.test_to_surface__surface_narrower_and_taller_than_masks"<<0#\\'2 "..!12 U+ !D;;##I#9D I LL '15-;MN1J MM* .   Z0024D E . L )$M U"rcN[R"S5n[R"S5nSnSn[R"U[S5n[R"S5nUR U5 UR 5nSHn[R RX8S9n U RUS 9n URU [R5 URU R5U5 U(a[X Xg5 [X X5 M[X U5 M g ) zEnsures that setsurfaces narrower and taller than the mask work correctly. For this test the setsurface's width is less than the mask's width and the setsurface's height is greater than the mask's height. rrr:rrrrrrNr) ryrr;rYr;rrWrrr!rs r9test_to_surface__setsurface_narrower_and_taller_than_maskFMaskTypeTest.test_to_surface__setsurface_narrower_and_taller_than_masks"<<0#\\'2 "^^$4hC !<<.()$--/!D;;##I#9DJ?J  ! !*fnn =   Z002I >#D6FX-&6$D6HI"rcN[R"S5n[R"S5nSnSn[R"U[S5n[R"S5nUR U5 UR 5nSHn[R RX8S9n U RUS 9n URU [R5 URU R5U5 U(a[X U5 M[X Xg5 [X X'5 M g ) zEnsures that unsetsurfaces narrower and taller than the mask work correctly. For this test the unsetsurface's width is less than the mask's width and the unsetsurface's height is greater than the mask's height. rrr:rrrrrrNr) ryrr;rYr;r#rvrrr!rs r;test_to_surface__unsetsurface_narrower_and_taller_than_maskHMaskTypeTest.test_to_surface__unsetsurface_narrower_and_taller_than_masks"<<0#\\'2 "~~&6"E #\\%0,-(113!D;;##I#9DlCJ  ! !*fnn =   Z002I >#D6FG#&8.&8"rc[R"S5n[R"S5nSnSn[R"U5n[R"S5nSHn[RR X7S9nUR 5n UR U5 U(aUOUn URU5n URX5 URU R5U5 [X X5 [X Xi5 M g) zEnsures that surfaces narrower and shorter than the mask work correctly. For this test the surface's width is less than the mask's width and the surface's height is less than the mask's height. rrrrrrrNr) ryrr;rYnarrow_short_sizerr rr!rZrTrs r7test_to_surface__surface_narrower_and_shorter_than_maskDMaskTypeTest.test_to_surface__surface_narrower_and_shorter_than_masks"<<0#\\'2 #..!23 U+ !D;;##I#9D I LL '15-;MN1J MM* .   Z0024E F . L )$M U"rcN[R"S5n[R"S5nSnSn[R"U[S5n[R"S5nUR U5 UR 5nSHn[R RX8S9n U RUS 9n URU [R5 URU R5U5 U(a[X Xg5 [X X5 M[X U5 M g ) zEnsures that setsurfaces narrower and shorter than the mask work correctly. For this test the setsurface's width is less than the mask's width and the setsurface's height is less than the mask's height. rrrErrrrrrNr) ryrr;rYrGrrWrrr!rs r:test_to_surface__setsurface_narrower_and_shorter_than_maskGMaskTypeTest.test_to_surface__setsurface_narrower_and_shorter_than_mask s"<<0#\\'2 #^^$5xD !<<.()$--/!D;;##I#9DJ?J  ! !*fnn =   Z002I >#D6FX-&6$D6HI"rcN[R"S5n[R"S5nSnSn[R"U[S5n[R"S5nUR U5 UR 5nSHn[R RX8S9n U RUS 9n URU [R5 URU R5U5 U(a[X U5 M[X Xg5 [X X'5 M g ) zEnsures that unsetsurfaces narrower and shorter than the mask work correctly. For this test the unsetsurface's width is less than the mask's width and the unsetsurface's height is less than the mask's height. rrrErrrrrrNr) ryrr;rYrGr#rvrrr!rs r#D6FG#&8.&8"rc^^[R"S5n[R"S5n[R"S5n[R"S5n[R"S5nSnSnSnS n [R"U5n [R"U5n [R"U 5n U RU5 U RU5 U RU5 U R 5mU R 5n U R 5n[R R US S 9nUR 5n[R"S S 5mURTlU4Sj[TRTR55HnURUS5 M URXU 5nURUU 5 URUR!5U5 UR#5 U4Sj[TR55HnUR%U5(dUnOMUR'U5(aU R%U5(aUnOUnOUR%U5(aUnOUnURUR'U5U5 M UR)5 g)zBEnsures that all the surface parameters can be of different sizes.rrrrar[)rr)ru)rr%)ruTrr/rc3z># UH0n[TRTR5HnX4v M M2 g7frG)r rr)r3rr unfilled_rects rr7WMaskTypeTest.test_to_surface__all_surfaces_different_sizes_than_mask..rs6 <=??MOO<F< # UH%n[TR5Ho!U4v M M' g7frG)r r)r3rr surface_rects rr7rUs) 1q5;PaF;PF1s-0N)r rr_rrOr!r r'rr rrrrrrQrrPr\rrR)ryrr;r rWrvrY surface_sizesetsurface_sizeunsetsurface_sizerrr#rrr!rZrWrrTrWrTs @@r7test_to_surface__all_surfaces_different_sizes_than_maskDMaskTypeTest.test_to_surface__all_surfaces_different_sizes_than_maskRsC"<<0#\\'2 U+ !<<0#\\&1   $...^^O4 ~~&78  ]#(),-'') $--/(113{{ 5MMO  FF3 (//  =??MOO< C KKQ   __W,G  j'* ,,. =  !,..1 C))#..!.S!!"//44%5N%5N%11#66%7N%7N   Z..s3^ D% ( rc Sn[R"X45nUR5nUR5n[R"S5n[R"S5n[R"S5nS[ U*US-55S[ U*US-55S[ U*US-55S [ U*US-554nS Hn [R RX4U S 9n U (aUOUn UH[n U HRn XlURU5nURU5 U RX$S 9n[XX5 [XX^5 MT M] M g )zBEnsures dest values can be different locations on/off the surface.rrrrc3(# UHoS4v M g7fr1r2r3ss rr7?MaskTypeTest.test_to_surface__dest_locations.. 43V3rc3*# UH nSU4v M g7fr1r2r_s rr7ra 43aV3c3(# UHoU4v M g7frGr2r_s rr7rarbrcc3*# UH o*U4v M g7frGr2r_s rr7ra 54b!W4rfrrrN)r r_rOrrr r!r rrNrrrXr^)rySIDErrW dest_rectr rr; directionsrr!rT directionrWrqrs rtest_to_surface__dest_locations,MaskTypeTest.test_to_surface__dest_locationssI..$.'')  %%'  U+ !<<0#\\'2 5UD5$(3 4 4UD5$(3 4 4UD5$(3 4 5eTE4!84 5  "D;;##TLt#>,#?LLL/!%!IJ'.W1-%( "rc Sn[R"X45n[R"S5n[R"S5n[R"S5nS[U*US-55S[U*US-55S[U*US-55S [U*US-554nS Hn[RR X4US 9nUR 5n U R5n U(aUOUn UHbn U HYn XlU RU 5nS UlURU5 URX*S 9n[XX5 [XX>5 M[ Md M g)z>Ensures area rects can be different locations on/off the mask.rrrrc3(# UHoS4v M g7fr1r2r_s rr7?MaskTypeTest.test_to_surface__area_locations..rbrcrc3*# UH nSU4v M g7fr1r2r_s rr7rrrerfc3(# UHoU4v M g7frGr2r_s rr7rrrbrcc3*# UH o*U4v M g7frGr2r_s rr7rrrirfrrr/rN)r r_rr r!r rOrrrNrrrXr^)ryrjrr rr;rlrr!rZrUrTrmrWrqrs rtest_to_surface__area_locations,MaskTypeTest.test_to_surface__area_locationssN..$. U+ !<<0#\\'2 5UD5$(3 4 4UD5$(3 4 4UD5$(3 4 5eTE4!84 5  "D;;##TLt#>)#.rbrcrc3*# UH nSU4v M g7fr1r2r_s rr7rzrerfc3(# UHoU4v M g7frGr2r_s rr7rzrbrcc3*# UH o*U4v M g7frGr2r_s rr7rzrirfr rr)r9rFN)r r_rOrrr rr!r rrNrrrXr^)ryrjrrWrkr rr;dest_directionsarea_positionsrr!rZrUrTdest_directiondest_posrarea_overlap_rectdest_overlap_rectrs r(test_to_surface__dest_and_area_locations5MaskTypeTest.test_to_surface__dest_and_area_locationss ..$.'')  %%'  U+ !<<0#\\'2 5UD5$(3 4 4UD5$(3 4 4UD5$(3 4 5eTE4!84 5  oa01!D;;##TLt#O6 *m=N%3!/#2 "rc SnSSSSUS- US- 4US- U4XS- 4X4US-U4XS-4US-US-44 n[R"X45n[R"S5n[R"S5n[R"S 5nS Hn[RR X4US 9nUR 5n U(aUOUn UHn [R "SU 5n URHYn XlU RU 5nSUlURU5 URX>)#>$J!>>$Qi@L LL ' OO, -   0 1"":.\B/."/.s 8D D' cSn[R"S5n[R"S5n[RRU5nSnUH|upg[R"XS9n[R"XS9n UR U5 U R U5 UR [5 URXS9 SSS5 M~ g!,(df  M=f)z]Ensures an exception is raised when surfaces have different depths than the created surface. rrar[))r%r%)rRrR)rr)rrR)rr%)rrR)rrrRrrrNr) ryrrWrvr!r set_depth unset_depthrr#s r7test_to_surface__different_depths_with_created_surfacesDMaskTypeTest.test_to_surface__different_depths_with_created_surfacess!<<0#\\&1{{%  '2 "I>J!>>$BL OO, -   0 1"":.:Q/.'2/.s 6C C" cSn[R"S5n[R"S5n[R"S5nSGHAnS[4GH0n[R"XUS9n[R"XUS9n[R"XUS9n UR U5 UR U5 U R U5 SHn [R R XS 9n U (aUOUn U RXxU 5n URU [R5 URU R5U5 [X U 5 U(dMURU R5U-5 M GM3 GMD g ) zHEnsures to_surface works correctly when the SRCALPHA flag is set or not.rrrar[rrrrrNr rrr_rr!r rrxrQrrXrr)ryrr rWrvrrrrr#rr!rTrs rtest_to_surface__same_srcalphas,MaskTypeTest.test_to_surface__same_srcalphass5 U+ !<<0#\\&1EX ..%H#^^DUK %~~duM  ]+ 01!!"45)D!;;++D+(FG*'rc`Sn[R"S5n[R"S5n[n[R"XSS9n[R"XSS9nUR U5 UR U5 SHn[R R XS9nU(aUOUn URXVS9n URU [R5 URU R5U5 [X U 5 URU R5U-5 M g ) zEnsures to_surface works correctly when it creates a surface and the SRCALPHA flag is set on both setsurface and unsetsurface. rrar[rrrrrNr) ryrrWrvexpected_flagsrr#rr!rTrs r5test_to_surface__same_srcalphas_with_created_surfacesBMaskTypeTest.test_to_surface__same_srcalphas_with_created_surfacess!<<0#\\&1!^^DbI ~~dK (),-!D;;##D#4D15-;MN%)J  ! !*fnn =   Z002D 9 . A OOJ002^C D"rcSn[R"S5n[R"S5n[R"S5n[RRU5n[SS4[[S4S[[4SS[44nSHnUHn[R "XSUS9n [R "XSUS9n [R "XS US9n U R U5 U R U5 U R U5 UR[5 URXU 5 S S S 5 M M g !,(df  M=f) zTEnsures an exception is raised when surfaces have different SRCALPHA flag settings. rrrar[rrrrr N r rr!r rr_rrrr) ryrr rWrvr! test_flagsrrrrr#s r$test_to_surface__different_srcalphas1MaskTypeTest.test_to_surface__different_srcalphass! U+ !<<0#\\&1{{%q!  x # ( # 8   E# ..1XUK#^^DaN %~~d(%P  ]+ 01!!"45&&z2OOGF32$32s (E  E cSn[R"S5n[R"S5n[RRU5nSHnS[S4S[44Hn[R "XSUS9n[R "XSUS9nUR U5 UR U5 UR[5 URXxS 9 S S S 5 M M g !,(df  M=f) zmEnsures an exception is raised when surfaces have different SRCALPHA flag settings than the created surface. rrar[rr/rrrrNr) ryrrWrvr!rrrr#s r:test_to_surface__different_srcalphas_with_created_surfacesGMaskTypeTest.test_to_surface__different_srcalphas_with_created_surfaces's!<<0#\\&1{{%E!8Q-!X?#^^DaN %~~d(%P  01!!"45&&z2OOzOU32@32s C// C> cf^ [R"S5n[R"S5nS=um p4[R"U[S5n[R"S5nSHn[RR XGS9nUR 5n U(aUOUn U 4Sj[U55Hrn URU5 Xl URX[S 9n URX5 URU R5U5 [X X5 [X Xi5 Mt M g ) zgEnsures dest values on the surface work correctly when using the defaults for setcolor and unsetcolor. rrrrrrrrc3P># UHn[T5Ho"U4v M M g7frGr/r0s rr7@MaskTypeTest.test_to_surface__dest_on_surface..MMAe 1Q r2rN)r rr_rr!r rOr rrrrrQrrXr^)ryrr;r:rrr rr!rZrTr9rr9s @r test_to_surface__dest_on_surface-MaskTypeTest.test_to_surface__dest_on_surface=s"<<0#\\'2%% v..x4 U+ !D;;##D#4D I15-;MNNvM ]+$(!!__W_@  j2  !4!4!6=#DnP-mN "rc n^S=ump[R"U[S5n[R"S5nUR 5n[R"S5nUR U5 UR 5n[R"S5nUR U5 UUUSS.n [ U 5n U RS5 S Hn [RRX+S 9n U R5n U (aUOUnU4S j[U55HnXl S HnUR U5 U(aU OU nUUS 'U R"S 0UD6nURUU5 URUR!5U5 [#UUX5 [%UUXM5 M M M g)zZEnsures dest values on the surface work correctly when using setsurface and unsetsurface. rrrrar[Nrrr#r9)r'N)r,Nrrc3P># UHn[T5Ho"U4v M M g7frGr/r0s rr7]MaskTypeTest.test_to_surface__dest_on_surface_with_setsurface_unsetsurface..|rr2r9r2)r r_rrrrrPupdater!r rOr rrrrQrrXr^)ryr:rrr rrWr#rvr color_kwargsrr!rZrTr9use_color_params test_kwargsrr9s @r=test_to_surface__dest_on_surface_with_setsurface_unsetsurfaceJMaskTypeTest.test_to_surface__dest_on_surface_with_setsurface_unsetsurfaceZs &% v..x4 U+ \\^ !<<0()||~ #\\&1,- $(  F| FG!D;;##D#4D I15-;MNNvM$(!(5$LL/2B,K*.K'!%!?;!?JMM*g6$$Z%8%8%:DA'j.T1j-)6N "rc[R"S5n[R"S5nS=up4n[R"U[S5n[R"S5nU*U*4U*S4SU*4/nUR [ UR 555 SHn [RRXYS9n U R 5n U (aUOUn UHrn URU5 Xl U RXmS 9nURX5 URUR5U5 [XX5 [!XX{5 Mt M g ) zhEnsures dest values off the surface work correctly when using the defaults for setcolor and unsetcolor. rrrrrrrrrN)r rr_rextendrDrOr!r rrrrrQrrXr^)ryrr;r9r:rrr rrr!rZrTr9rs r!test_to_surface__dest_off_surface.MaskTypeTest.test_to_surface__dest_off_surfaces*"<<0#\\'2%% ..x4 U+ &6'"eVQK!fW> [!1!1!345!D;;##D#4D I15-;MN ]+$(!!__W_@  j2  !4!4!6=#DnP-m "rc S=upn[R"U[S5n[R"S5nUR 5n[R"S5nUR U5 UR 5n[R"S5n UR U 5 U*U*4U*S4SU*4/n U R [UR555 UUUSS.n [U 5n U RS 5 S Hn [RRX=S 9nUR5nU (aUOU nU HnUUl S HnUR U5 U(aU OU nUUS 'UR"S 0UD6nURUU5 UR!UR#5U5 [%UUUU5 ['UUX_5 M M M g)z[Ensures dest values off the surface work correctly when using setsurface and unsetsurface. rrrrar[rNrrrrr9r2)r r_rrrrrrDrOrPrr!r rrrrQrrXr^)ryr9r:rrr rrWr#rvrrrrr!rZrTr9rrrs r>test_to_surface__dest_off_surface_with_setsurface_unsetsurfaceKMaskTypeTest.test_to_surface__dest_off_surface_with_setsurface_unsetsurfaces &% ..x4 U+ \\^ !<<0()||~ #\\&1,-&6'"eVQK!fW> [!1!1!345 $(  F| FG!D;;##D#4D I15-;MN$( !(5$LL/2B,K*.K'!%!?;!?JMM*g6$$Z%8%8%:DA'j.)T1j-)6 "rc^[R"S5n[R"S5nS=ump4[R"U[S5n[R"S5nSHn[RR XGS9nUR 5n U R5n U(aUOUn U4Sj[U55Hn URU5 Xl U RU 5n S U l URXZS 9nURX5 URUR5U5 [!XX5 [#XXm5 M M g ) zdEnsures area values on the mask work correctly when using the defaults for setcolor and unsetcolor. rrrrrrrc3P># UHn[T5Ho"U4v M M g7frGr/r0s rr7=MaskTypeTest.test_to_surface__area_on_mask..L 1uU|!A| r2r/rN)r rr_rr!r rOrr rrrNrrrQrrXr^)ryrr;r:rrr rr!rZrUrTrWrqrr9s @rtest_to_surface__area_on_mask*MaskTypeTest.test_to_surface__area_on_masks "<<0#\\'2%% v..x4 U+ !D;;##D#4D I!(I15-;MNMf L ]+$'!(~~i8 '- $!__W_E  j2  !4!4!6=#DnS-mM"rc 2^S=ump[R"U[S5n[R"S5nUR 5n[R"S5nUR U5 UR 5n[R"S5nUR U5 UUU[R "SU5S.n [U 5n U RS5 S GH1n [RRX+S 9n U R5n U R 5nU (aUOUnU4S j[U55HnUUl U RU5nSUl S HnUR U5 U(aU OU nUUS l U RUS 5nSUl U R"S0UD6nUR!UU5 UR#UR%5U5 ['UUUU5 [)UUUU5 M M GM4 g )zWEnsures area values on the mask work correctly when using setsurface and unsetsurface. rrrrar[r/rrr#rFrrrc3P># UHn[T5Ho"U4v M M g7frGr/r0s rr7ZMaskTypeTest.test_to_surface__area_on_mask_with_setsurface_unsetsurface..(rr2rFNr2)r r_rrrrr'rPrr!r rOr rrNrrrQrrXr^)ryr:rrr rrWr#rvrrrr!rZrUrTrWrqrrrr9s @r:test_to_surface__area_on_mask_with_setsurface_unsetsurfaceGMaskTypeTest.test_to_surface__area_on_mask_with_setsurface_unsetsurfaces &% v..x4 U+ \\^ !<<0()||~ #\\&1,- $(KK-  F| FG!D;;##D#4D I!(I15-;MNMf L$' !(~~i8 '- $(5$LL/2B,K25K'/#,>>+f2E#FL+1L(!%!?;!?JMM*g6$$Z%8%8%:DA'j.,W1j-)6 M"rc [R"S5n[R"S5nS=up4n[R"U[S5n[R"S5nU*U*4U*S4SU*4/nUR [ [R "SX44555 SHn [RRXYS 9n U R5n U R5n U (aUOUn UHnURU5 Xl U RU 5nSUl U RXlS 9nURUU5 UR!UR#5U5 [%UUX5 ['UUX5 M M g ) zeEnsures area values off the mask work correctly when using the defaults for setcolor and unsetcolor. rrrrrrr/rrrN)r rr_rrrDr'r!r rOrrrrNrrrQrrXr^)ryrr;r9r:rrr  positionsrr!rZrUrTrWrqrs rtest_to_surface__area_off_mask+MaskTypeTest.test_to_surface__area_off_mask=sX "<<0#\\'2%% ..x4 U+ fvg&% a&\B V[[%%IJK!D;;##D#4D I!(I15-;MN  ]+$'!(~~i8 '- $!__W_E  j'2  !4!4!6=#D*nS-*m! "rc &S=upn[R"U[S5n[R"S5nUR 5n[R"S5nUR U5 UR 5n[R"S5n UR U 5 U*U*4U*S4SU*4/n U R [[R"SX4555 UUU[R"SU5S.n [U 5n U RS 5 S Hn [RRX=S 9nUR5nU (aUOU nU HnS HnUR U5 U(aU OU nUUS lURUS 5nSUlUR "S0UD6nUR#UU5 UR%UR'5U5 [)UUUU5 [+UUUU5 M M M g )zXEnsures area values off the mask work correctly when using setsurface and unsetsurface. rrrrar[rr/rrrrrFNr2)r r_rrrrrrDr'rPrr!r rOrrNrrrQrrXr^)ryr9r:rrr rrWr#rvrrrrr!rZrTrWrrrqrs r;test_to_surface__area_off_mask_with_setsurface_unsetsurfaceHMaskTypeTest.test_to_surface__area_off_mask_with_setsurface_unsetsurfacebs &% ..x4 U+ \\^ !<<0()||~ #\\&1,-fvg&% a&\B V[[%%IJK $(KK-  F| FG!D;;##D#4D I15-;MN (5$LL/2B,K25K'/#,>>+f2E#FL+1L(!%!?;!?JMM*g6$$Z%8%8%:DA'j.,W1j-)6! "rcZSnSn[R"U5n[RRSSS9nUR U5nUR XS5 [ (d&UR[R"U5U5 URUR5U5 g)z2Ensures zero sized surfaces are handled correctly.rr/rrTrN) r r_r!r rrrrQr r r)ryr rrr!rs r'test_to_surface__surface_with_zero_size4MaskTypeTest.test_to_surface__surface_with_zero_sizes..&{{T2__W-  j*w   S__Z8:L M ,,.5rcNSn[nSn[R"S5nSn[RR USS9n[R "SX#5nUR US9nURU[R 5 [(d&UR[R"U5U5 URUR5U-5 URUR5U5 URUR5U5 [!XU5 g ) z5Ensures zero sized setsurfaces are handled correctly.r rrr rTrr/rNrr rr!r r_rrxrrQr r rrrrrX) ryr rrrTrYr!rrs r*test_to_surface__setsurface_with_zero_size7MaskTypeTest.test_to_surface__setsurface_with_zero_sizes g. {{ 5^^FMJ __ _;  j&..9w   S__Z8:L M  ,,.>? //1>B ,,. :Dn=rcPSn[nSn[R"S5nSn[RR U5n[R "SX#5nUR US9nURU[R 5 [(d&UR[R"U5U5 URUR5U-5 URUR5U5 URUR5U5 [!XU5 g)z7Ensures zero sized unsetsurfaces are handled correctly.r rrrr/rNr) ryr rrrTrYr!r#rs r,test_to_surface__unsetsurface_with_zero_size9MaskTypeTest.test_to_surface__unsetsurface_with_zero_sizes g. {{ *~~fmL __,_?  j&..9w   S__Z8:L M  ,,.>? //1>B ,,. :Dn=rcSH|nSHsnSUSU3n[RRXS9nURU[RRU5 UR UR 5X5 Mu M~ g)z-Ensures masks can be created with zero sizes.)rr)rrr/rrz, fill=rN)r r!r rxrQr)ryrrr`r!s rtest_zero_maskMaskTypeTest.test_zero_masksq0D%dV74&1{{'''8%%dFKK,<,   Y - DT 28rcSHCn[RRU5nUR5nUR X15 ME g)z4Ensures get_size correctly handles zero sized masks.))rr)r(r/N)r r!r rrQryr{r!rs rtest_zero_mask_get_size$MaskTypeTest.test_zero_mask_get_sizes97M;;##M2D==?D   T 1 8rcSHZn[R"SU5n[RRU5nUR 5nUR XB5 M\ g)z4Ensures get_rect correctly handles zero sized masks.)r)rrr/r/N)r r'r!r rOrQ)ryr{rr!rCs rtest_zero_mask_get_rect$MaskTypeTest.test_zero_mask_get_rectsI5M"KK >M;;##M2D==?D   T 1 6rcSHQn[RRU5nUR[5 UR S5nSSS5 MS g!,(df  Me=f)z2Ensures get_at correctly handles zero sized masks.))3r)rrr/r/Nr )ryrr!rs rtest_zero_mask_get_at"MaskTypeTest.test_zero_mask_get_atsM.D;;##D)D"":. F+/.//. A A( cSHQn[RRU5nUR[5 UR S5 SSS5 MS g!,(df  Me=f)z2Ensures set_at correctly handles zero sized masks.))rr)rr/r/Nr&rs rtest_zero_mask_set_at"MaskTypeTest.test_zero_mask_set_atsK.D;;##D)D"":. F#/.//.rcSn[SS5Hkup#SUSU3n[RRUSS9n[RRUSS9nUR Xa5nUR Xt5 Mm g) zgEnsures overlap correctly handles zero sized masks. Tests combinations of sized and zero sized masks. r/r*size1=, size2=TrN)r;r r!r r.rL)ryr/size1size2r`r|r}r7s rtest_zero_mask_overlap#MaskTypeTest.test_zero_mask_overlap s| +B3LE5'%1CKK$$U$6EKK$$U$6E--6K   k /4rcSnSn[SS5Hlup4SUSU3n[RRUSS9n[RRUSS9nUR Xq5nUR XU5 Mn g ) zlEnsures overlap_area correctly handles zero sized masks. Tests combinations of sized and zero sized masks. r/rr4r r TrN)r;r r!r rbrQ) ryr/rzrrr`r|r}rks rtest_zero_mask_overlap_area(MaskTypeTest.test_zero_mask_overlap_areas +B3LE5'%1CKK$$U$6EKK$$U$6E!..u=M   ]C @4rcSnSn[SS5Hup4SUSU3n[RRUSS9n[RRUSS9nUR Xq5nUR U[RRU5 UR UR5X%5 UR UR5X55 M g ) zlEnsures overlap_mask correctly handles zero sized masks. Tests combinations of sized and zero sized masks. r/rrrr r TrN) r;r r!r rrxrQrar) ryr/rzrrr`r|r}rs rtest_zero_mask_overlap_mask(MaskTypeTest.test_zero_mask_overlap_mask*s +B3LE5'%1CKK$$U$6EKK$$U$6E --e G   \224e A4rcSnSHVn[RRU5nUR5 UR UR 5USU35 MX g)z0Ensures fill correctly handles zero sized masks.rrrN)r r!r rrQra)ryrzrr!s rtest_zero_mask_fill MaskTypeTest.test_zero_mask_fill=sL0D;;##D)D IIK   TZZ\>U4&> J 1rcSnUHRn[RRU5nUR5 UR UR 5S5 MT gNrr)r r!r rrQraryr6rr!s rtest_zero_mask_clear!MaskTypeTest.test_zero_mask_clearHsD,D;;##D)D JJL   TZZ\1 -rcSnUHRn[RRU5nUR5 UR UR 5S5 MT gr)r r!r rrQrars rtest_zero_mask_flip MaskTypeTest.test_zero_mask_flipPsD,D;;##D)D KKM   TZZ\1 -rcSnUH}n[RRU5nURS5nUR U[RR5 UR UR 5S5 M g)Nrr r)r r!r rrxrQr)ryr6rr!r}s rtest_zero_mask_scale!MaskTypeTest.test_zero_mask_scaleXsd,D;;##D)DJJv&E  ! !%)9)9 :   U^^-v 6 rc|Sn[SS5Hup#SUSU3n[RRUSS9n[RRUSS9nUR 5nUR Xa5 UR UR 5Xt5 UR UR5X$5 M g) zdEnsures draw correctly handles zero sized masks. Tests combinations of sized and zero sized masks. r/rrr r TrN)r;r r!r rarrQrryr/rrr`r|r}rzs rtest_zero_mask_draw MaskTypeTest.test_zero_mask_drawbs +B3LE5'%1CKK$$U$6EKK$$U$6E"[[]N JJu %   U[[]N @   U^^-u :4rc|Sn[SS5Hup#SUSU3n[RRUSS9n[RRUSS9nUR 5nUR Xa5 UR UR 5Xt5 UR UR5X$5 M g) zeEnsures erase correctly handles zero sized masks. Tests combinations of sized and zero sized masks. r/rvr r TrN)r;r r!r rarrQrr)s rtest_zero_mask_erase!MaskTypeTest.test_zero_mask_erasets +B3LE5'%1CKK$$U$6EKK$$U$6E"[[]N KK &   U[[]N @   U^^-u :4rcSnUHAn[RRUSS9nURUR 5S5 MC g)NrTrr)r r!r rQrars rtest_zero_mask_count!MaskTypeTest.test_zero_mask_counts@,D;;##Dt#4D   TZZ\1 -rcSnUHBn[RRU5nURUR 5S5 MD g)Nrr/)r r!r rQr=rs rtest_zero_mask_centroid$MaskTypeTest.test_zero_mask_centroids;,D;;##D)D   T]]_f 5rcSnUHBn[RRU5nURUR 5S5 MD g)Nrrh)r r!r rQrbrs rtest_zero_mask_angle!MaskTypeTest.test_zero_mask_angles;,D;;##D)D   TZZ\3 /rc/nSHGn[RRU5nUR5nUR XASU35 MI g)z3Ensures outline correctly handles zero sized masks.))rrr<r/rNr r!r rxrryexpected_pointsrr!r(s rtest_zero_mask_outline#MaskTypeTest.test_zero_mask_outlinesF.D;;##D)D\\^F  E$. I /rc/nSHHn[RRU5nURS5nUR XASU35 MJ g)zWEnsures outline correctly handles zero sized masks when using the skip pixels argument.))rr)rrr/rrNr<r=s r test_zero_mask_outline__with_arg-MaskTypeTest.test_zero_mask_outline__with_argsK.D;;##D)D\\"%F  E$. I /rc SHn[RRUSS9nSHnSUSU3n[RRUSS9n[SUSUS-S- 5[SUSUS-S- 54nUR U5nUR U[RRU5 UR XuU5 URUR5Xd5 M M g ) zvEnsures convolve correctly handles zero sized masks. Tests the different combinations of sized and zero sized masks. ))rrrrrFr/Tr)rQrr:r/sizes=rrrN) r r!r r&r|rxrrQr)ryrr|rr`r}r{r!s rtest_zero_mask_convolve$MaskTypeTest.test_zero_mask_convolves :EKK$$U$6E<ugRw/ ((T(:58eAh.2358eAh.23! ~~e,%%dFKK,<,r/)rSrErFr/rJrN)r r!r r|rxrrQr) ryrr|rr} output_sizer` output_maskr!s r)test_zero_mask_convolve__with_output_mask6MaskTypeTest.test_zero_mask_convolve__with_output_masks :EKK$$U$6E= ((T(:#EK"5'E7"[MBC"(++"2"2;"?K >>%=D))$ 0@0@#FMM$S9$$T]]_kG$F>:rcXSnSHnSU3n[RRU5nUR5nUR U[RRU5 UR UR 5U5 UR UR5X5 M g)z?Ensures connected_component correctly handles zero sized masks.r)rH)rPr/rN)r r!r rrxrQrra)ryrzrr`r!cc_masks r"test_zero_mask_connected_component/MaskTypeTest.test_zero_mask_connected_components.D$.C;;##D)D..0G  ! !'6;;+;+;S A   W--/ 6   W]]_n B/rcSHQn[RRU5nUR[5 UR S5nSSS5 MS g!,(df  Me=f)z\Ensures connected_component correctly handles zero sized masks when using an index argument.)rNrPr/r/N)r r!r rr r)ryrr!rYs r+test_zero_mask_connected_component__indexed8MaskTypeTest.test_zero_mask_connected_component__indexedsQ/D;;##D)D"":.226:/.//.rc/nSHGn[RRU5nUR5nUR XASU35 MI g)z@Ensures connected_components correctly handles zero sized masks.)rrr/rN)r r!r rr)ryexpected_cc_masksrr!cc_maskss r#test_zero_mask_connected_components0MaskTypeTest.test_zero_mask_connected_componentssJ.D;;##D)D002H  dVn M /rc/nSHGn[RRU5nUR5nUR XASU35 MI g)z>Ensures get_bounding_rects correctly handles zero sized masks.))r"r)rrsr/rN)r r!r rr)ryexpected_bounding_rectsrr!bounding_rectss r!test_zero_mask_get_bounding_rects.MaskTypeTest.test_zero_mask_get_bounding_rectssM"$.D;;##D)D!446N  5  /rc[R"S5n[R"S5nSHn[R"U[S5nUR U5 SHun[R R USS9nURXAS9nURXt5 URUR5U5 S U;dMi[XU5 Mw M g ) zCEnsures to_surface correctly handles zero sized masks and surfaces.r[r)r)rr)rrr/r))rr)rrr/TrrrN) r rr_rrr!r rrrQrrX)ry mask_color surf_colorrBrrYr!rs rtest_zero_mask_to_surface&MaskTypeTest.test_zero_mask_to_surface s\\&) \\%( 9InnY"=G LL $5 {{'' '=!__W_J  j2  !4!4!6 BI%'*E6 :rc[R"S5nSHpn[RRUSS9nUR US9nUR U[R 5 URUR5U5 Mr g)zlEnsures to_surface correctly handles zero sized masks and surfaces when it has to create a default surface. r[)rrr/TrrN) r rr!r rrxr_rQr)ryrjrYr!rs r)test_zero_mask_to_surface__create_surface6MaskTypeTest.test_zero_mask_to_surface__create_surface!sr\\&) 1I;;##ID#9D*=J  ! !*fnn =   Z002I > 2rr2N)F)__name__ __module__ __qualname____firstlineno__r?unittestskipIfrr~rrrrrrrrrrrrrrrrrrrrr#r'r8rBrHrPrUr[rarfrlrrruryr}rrrrrrrrrrrrrrrrrrrrrrrrrr rrrrrr!r%r(r+r3r7r:r?rCrHrKrOrRrUr^rerkroryrrrrrrrrrrrrrrrrrrrrrrrr r$r)r/r2r5r<rCexpectedFailurerGrJrTrXr]rernrrrxrrrrrrrrrrrrrrrrrrrrrrrrr rrrrrrr!r'r*r-r1r4r7r<r?rBrHrKrNr[rnrvrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr"r&r*r.r1r4r7r?rBrKrUrZr]rbrgrlro__static_attributes__r2rrrhrhs N__W12:3: ) B__W12F3F( BC&;$ ; ;*9 2__W125:35:n .)__W12 .3 ..2 M!">$>$>$!"!GF@.">H<8@<__W12G3G:__W12=3=7__W12!G3!GF__W12@3@:@>__W12!G3!GFD>"GH__W127372 @D__W12!D3!DF @D__W12&G3&GPC=D& 9__W123$ 9&__W12838> 9 9__W123*__W12S3S6 !G@@B$=L@8__W12(G3(GT,&G@@B$=L@8__W12(G3(GT-'9 __W123< 9 96 9>">&>">& 6>0 0 9'*M( 0 '2 D__W12 3 ",,*XB$B&! F$ L=. F):V5(5*05d__W12w3wr__W12B3B(F2B0B6B4B0 >B4 >B@R.BB>R0B>BB>(B>%*N&+BZB*B* 3 7B" + B BVV@??$QQ0BB*RVhUVn# J?$BB0J@ D MD"HV4B.B0B0J@ D MD"HV4B0B0V6B2B2V8 JD"HV8 JD"HV8 JD"H__W12B3BH!F __W12"3"H33j))VB4B$F>CBR@H:E:G>V,:1f@3j __W123@66p __W12!3!F __W12434l 6>(>( = 322,$0 A"B& K..7;$;$.60 J JF,H, C; N F( ?rrhc,^\rSrSrSrU4SjrSrU=r$)SubMaski0z4Subclass of the Mask class to help test subclassing.c4>[TU]"U0UD6 SUlg)NT)super__init__test_attribute)ryrwr __class__s rr}SubMask.__init__3s $)&)"r)r~)rqrrrsrt__doc__r}rx __classcell__rs@rrzrz0s>##rrzc,^\rSrSrSrU4SjrSrU=r$) SubMaskCopyi8;Subclass of the Mask class to help test copying subclasses.cF>[TU]5nURUlU$rG)r|rr~ryrrs rrSubMaskCopy.copy;s"GLN #'#6#6  rr2rqrrrsrtrrrxrrs@rrr8Errc,^\rSrSrSrU4SjrSrU=r$)SubMaskDunderCopyiArcF>[TU]5nURUlU$rG)r|__copy__r~rs rrSubMaskDunderCopy.__copy__Ds$G$& #'#6#6  rr2)rqrrrsrtrrrxrrs@rrrArrrc,^\rSrSrSrU4SjrSrU=r$)SubMaskCopyAndDunderCopyiJrc >[TU]5$rG)r|r)ryrs rrSubMaskCopyAndDunderCopy.copyMsw|~rr2rrs@rrrJsErrc\rSrSrSrSrSrSrSrSr Sr S r S r S r S rS rSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSr g) MaskSubclassTestiQzTest subclassed Masks.c[SSS9nURU[RR5 URU[5 UR UR 5 g)z)Ensures the Mask class can be subclassed.r^TrN)rzrxr r!r rr~rs rtest_subclass_mask#MaskSubclassTest.test_subclass_maskTsJvD) dFKK$4$45 dG, ++,rcb[SSS9nUR5[R"U54H{nURU[RR 5 URU[5 UR X!5 [XU5 UR[US55 M} g)z(Ensures copy works for subclassed Masks.rr Trr~N) rzrrxr r!r rrf assertFalsehasattrryr!rs rtest_subclass_copy#MaskSubclassTest.test_subclass_copy\swT*))+tyy7I  ! !)V[[-=-= >  ! !)W 5   Y - DT 2   WY0@A B 8rc[SSS9n[UR5[R"U545Hup#URU[R R 5 URU[5 URX15 [XU5 SU:XaUR[US55 MURUR5 M g)z8Ensures copy works for subclassed Masks overriding copy.rTrrr~N) rrXrrxr r!r rrfrrrr~)ryr!rrs r!test_subclass_copy__override_copy2MaskSubclassTest.test_subclass_copy__override_copyis7.&tyy{DIIdO&DELA  ! !)V[[-=-= >  ! !)[ 9   Y - DT 2Av  4D!EF 8 89Frcb[SSS9nUR5[R"U54H{nURU[RR 5 URU[5 UR X!5 [XU5 URUR5 M} g)z  ! !)-> ?   Y - DT 2 OOI44 58rcb[SSS9nUR5[R"U54H{nURU[RR 5 URU[5 UR X!5 [XU5 URUR5 M} g)zAEnsures copy works for subclassed Masks overriding copy/__copy__.rTrN) rrrxr r!r rrfrr~rs r.test_subclass_copy__override_both_copy_methods?MaskSubclassTest.test_subclass_copy__override_both_copy_methodss'd;))+tyy7I  ! !)V[[-=-= >  ! !)-E F   Y - DT 2 OOI44 5 8rc`Sn[U5nUR5nURX15 g)z,Ensures get_size works for subclassed Masks.r%N)rzrrQrs rtest_subclass_get_size'MaskSubclassTest.test_subclass_get_sizes* }%}} -rc[R"SS5n[URSS9nUR 5nUR X15 g)z,Ensures get_rect works for subclassed Masks.r/)rrTrN)r r'rzrrOrQ)ryrr!rCs rtest_subclass_mask_get_rect,MaskSubclassTest.test_subclass_mask_get_rects= FH5 }))5}} -rc`Sn[SSS9nURS5nURX15 g)z*Ensures get_at works for subclassed Masks.rrTrr/N)rzrrQ)ryrr!bits rtest_subclass_get_at%MaskSubclassTest.test_subclass_get_ats/ vD)kk&! +rcSnSnSn[SSS9nURU5 URURU5U5 URUR 5U5 g)z*Ensures set_at works for subclassed Masks.rr/FrrN)rzrrQrra)ryrrzrWr!s rtest_subclass_set_at%MaskSubclassTest.test_subclass_set_atsX E/ C S)<8 ~6rcSnSn[RRSUS9[US54n[RRSUS9[US54nUH/nUH&nUR US5nUR Xq5 M( M1 g)z+Ensures overlap works for subclassed Masks.r/r%TrN)r r!r rzr.rQ)ryr6rYmasks arg_masksr!arg_maskr7s rtest_subclass_overlap&MaskSubclassTest.test_subclass_overlaps  !!t)!VW KK  $Y  7 It $ D%"ll8V<   ;&rc0SnUSUS-n[RRSUS9[US54n[RRSUS9[US54nUH/nUH&nUR US5nUR Xr5 M( M1 g)z0Ensures overlap_area works for subclassed Masks.rrrTrr/N)r r!r rzrbrQ)ryrYrzrrr!rrks rtest_subclass_overlap_area+MaskSubclassTest.test_subclass_overlap_areas "1 ! 4!!t)!VW KK  $Y  7 It $ D% $ 1 1(F C   ?&rcSnUSUS-n[RRSUS9[US54n[RRSUS9[US54nUHnUHnUR US5nUR U[RR5 UR U[5 URUR5U5 URUR5U5 M M g)z0Ensures overlap_mask works for subclassed Masks.rrrTrr/N) r r!r rzrrxassertNotIsInstancerQrar)ryr{rzrrr!rrs rtest_subclass_overlap_mask+MaskSubclassTest.test_subclass_overlap_masks &q)M!,<< KK  $]  ; M4 (  KK  $]  ; M4 ( D%#006B %%lFKK4D4DE((w?  !3!3!5~F  !6!6!8-H &rcSnUSUS-n[SUS9nUR5 URUR5U5 g)z(Ensures fill works for subclassed Masks.rrrFrN)rzrrQraryrYrzr!s rtest_subclass_fill#MaskSubclassTest.test_subclass_fillsD "1 ! 4E 2  ~6rcSnSn[US5nUR5 URUR5U5 g)z)Ensures clear works for subclassed Masks.)rrrTN)rzrrQrars rtest_subclass_clear$MaskSubclassTest.test_subclass_clears7 y$'  ~6rcSnUSUS-n[SUS9nUR5 URUR5U5 g)z*Ensures invert works for subclassed Masks.rrrrFrN)rzrrQrars rtest_subclass_invert%MaskSubclassTest.test_subclass_invertsD "1 ! 4E 2  ~6rcSn[S5nURU5nURU[RR 5 UR U[5 URUR5U5 g)z)Ensures scale works for subclassed Masks.rrN) rzrrxr r!r rrQr)ryr{r! scaled_masks rtest_subclass_scale$MaskSubclassTest.test_subclass_scalesa vjj/  k6;;+;+;<   g6 --/?rcjSnUSUS-n[RRSUS9[US54n[RRU5[U54HNnUHEnUR 5 UR US5 UR UR5U5 MG MP g)z(Ensures draw works for subclassed Masks.rrrTrr/N)r r!r rzrrrQra)ryrYrzrr!rs rtest_subclass_draw#MaskSubclassTest.test_subclass_draws "1 ! 4 KK  $Y  7 It $ [[%%i0')2DED%  (F+  ~> &FrcdSnSn[RRUS5[US54n[RRUS5[US54nUHNnUHEnUR 5 UR US5 UR UR5U5 MG MP g)z)Ensures erase works for subclassed Masks.rrTr/N)r r!r rzrrrQra)ryrYrzrrr!rs rtest_subclass_erase$MaskSubclassTest.test_subclass_erase/s !!)T2GIt4LM[[%%i6 48PQ D%  8V,  ~> &rcSnUSUS-S- n[SUS9nURSS5 UR5nURXB5 g)z)Ensures count works for subclassed Masks.rrrTrrkN)rzrrarQ)ryrYrzr!ras rtest_subclass_count$MaskSubclassTest.test_subclass_count?sQ "1 ! 4q8Dy1 FA  /rcdSnSn[S5nUR5nURXA5 g)z,Ensures centroid works for subclassed Masks.r/rN)rzr=rQ)ryr>rYr!r=s rtest_subclass_centroid'MaskSubclassTest.test_subclass_centroidJs/" v==? 5rc\Sn[SS9nUR5nURX15 g)z)Ensures angle works for subclassed Masks.rhrrwN)rzrbrj)ryrdr!rbs rtest_subclass_angle$MaskSubclassTest.test_subclass_angleTs*F#  u5rc`/n[S5nUR5nURX15 g)z+Ensures outline works for subclassed Masks.rN)rzrxr)ryexpected_outliner!rxs rtest_subclass_outline&MaskSubclassTest.test_subclass_outline]s*v,,. W7rc2SupX4nSn[SUS-S- 5[SUS-S- 54n[RRU5[ U54n[RRU5[ U54n[RRU5[ U54GHgnUGH\n UR U 5n UR U [RR5 URU [5 URU R5U5 URU R5U5 UHn UR X5n UR U [RR5 URU R5U5 URU R5U5 [U [5(aUR U [5 MURU [5 M GM_ GMj g)z,Ensures convolve works for subclassed Masks.rSrr rN) r&r r!r rzr|rxrrQrar isinstance) ryr9r:rYrzr{r output_masksr!rrrTs rtest_subclass_convolve'MaskSubclassTest.test_subclass_convolvefs O Q A .AvzA~0FG [[%%i0')2DE  ((3WY5GH [[%%i0')2DED% $ h 7 %%mV[[5E5EF((@  !4!4!6G  !7!7!9=I$0K$(MM($HM))-9I9IJ$$]%8%8%:NK$$]%;%;%=yI!+w77--mWE00H$0&FrcBSnSn[U5nUR5nURU[RR 5 UR U[5 URUR5U5 URUR5U5 g)z7Ensures connected_component works for subclassed Masks.rrN) rzrrxr r!r rrQrar)ryrzr{r!rYs r!test_subclass_connected_component2MaskSubclassTest.test_subclass_connected_components} }%**, gv{{'7'78   '2 .9 ))+];rc`/n[S5nUR5nURX15 g)z8Ensures connected_components works for subclassed Masks.rN)rzrr)ry expected_ccsr!ccss r"test_subclass_connected_components3MaskSubclassTest.test_subclass_connected_componentss, v'') S/rc`/n[S5nUR5nURX15 g)z6Ensures get_bounding_rects works for subclassed Masks.rN)rzrr)ryrer!rfs r test_subclass_get_bounding_rects1MaskSubclassTest.test_subclass_get_bounding_rectss-"$v002 ^Ercb[R"S5nSn[USS9n[R"U[S5nUR [R"S55 UR XAS9nURXT5 URUR5U5 [XU5 g) z.Ensures to_surface works for subclassed Masks.r[r^TrrrrN) r rrzr_rrrrrQrrXr\s rtest_subclass_to_surface)MaskSubclassTest.test_subclass_to_surfacesf-t$'..x4 V\\%()__W_F  j* ,,.5Dn=rr2N)!rqrrrsrtrrrrrrrrrrrrrrrrrrrrrrrrrrrrrxr2rrrrQs - C:" 6 6.., 7<"@"I.777 @?$? 0668IB <0F >rrzpypy has lots of mask failurescP\rSrSrSrSrSrSrSrSr Sr S r S r S r S rg )MaskModuleTestic fSn/SQnSnUSUS-nSnSGHn[R"U[U5n[U5HnXS'UR U5 US:aUR S 5SnS SUS- XS-S S1n U Hn S US USU 3n X:aUn OUn [R RXzS9n URU [R RU 5 URU R5X;5 URU R5X5 M M GM g)a{Ensures from_surface creates a mask with the correct bits set. This test checks the masks created by the from_surface function using 16 and 32 bit surfaces. Each alpha value (0-255) is tested against several different threshold values. Note: On 16 bit surface the requested alpha value can differ from what is actually set. This test uses the value read from the surface. )7r|r)rurrrrrrr/rnr|depth=z, alpha=z , threshold=)rr N) r r_rr rrr!rarxr rQrra)rythreshold_countr r{ all_set_countnone_set_countrralphathreshold_test_valuesr r`rzr!s rtest_from_surface MaskModuleTest.test_from_surfaces=)  %a(=+;; Enn]HeDG/#(a  ]+2:$NN6215E*,Q 5!)SRU(V%!6I"5'% YKPC()6)7!;;33 '4D))$ 0@0@#F$$T]]_mI$$TZZ\>G"70rcSnSn/SQnUS4n[R"USS9n[R"U[S5nUR 5 [ U5HnXsS'UR US 4U5 M UR5 [ U5HnS U3n UR US 4S 5 UR5n [RRXh5n URU [RRU 5 URU R5XI5 URU R5X5 URU RXQ5X5 M g ) acEnsures from_surface creates a mask with the correct bits set when pixels have different alpha values (32 bits surfaces). This test checks the masks created by the from_surface function using a 32 bit surface. The surface is created with each pixel having a different alpha value (0-255). This surface is tested over a range of threshold values (0-255). r/r)rrsrrrTrrrr threshold=N)r r r_rrPr rrRrar!rarxrQrrb) ryr/rr r{rrr4r r`rzr!s r)test_from_surface__different_alphas_32bit8MaskModuleTest.test_from_surface__different_alphas_32bits8' (!,  M= .."=  'A !  NNAq6= 1( /Iyk*C  )Q 3*002N;;++G?D  ! !$ (8(8# >   T]]_m A   TZZ\> ?   !!-8. 0rc8Sn/SQnUS4n[R"U[S5nUR5 [ U5HnXRS'UR US4U5 M UR 5 [5n[5n[ U5HOnURUS45Sn X;aU/Xi'OXiRU5 X:dM>URU5 MQ /n Sn [R"U5n [R"USS 9n UR5HnUHnX;aU RXS-U 45 M US S-n[ U5HnU R US4S5 M [R"USS 9n U RX5 U RXU 45 M M U HunnnUR5n[ UU5HnS U3n[R R#XH5nUR%U[R RU5 UR'UR)5UU5 UR'UR5UU5 UR'UR+UU 5UU5 M M g ) aEnsures from_surface creates a mask with the correct bits set when pixels have different alpha values (16 bit surfaces). This test checks the masks created by the from_surface function using a 16 bit surface. Each pixel of the surface is set with a different alpha value (0-255), but since this is a 16 bit surface the requested alpha value can differ from what is actually set. The resulting surface will have groups of alpha values which complicates the test as the alpha groups will all be set/unset at a given threshold. The setup calculates these groups and an expected mask for each. This test data is then used to test each alpha grouping over a range of threshold values. r)nxrrrRrrr/TrrnrN)r r_rrPr rrRrsetrraddr rrrar!rarxrQrrb)ryrr r{rr4alpha_thresholdsspecial_thresholdsr rrRr/ erase_maskexp_mask thresholds to_thresholdthresfrom_thresholdrrzr`r!s r)test_from_surface__different_alphas_16bit8MaskModuleTest.test_from_surface__different_alphas_16bit sh* (!, .."=  'A !  NNAq6= 1( &= U/INNIq>215E,+4+ ' '..y9 "&&y10 [[/ ;;}48*113J' 2$$iQ%IJ#-b>A#5L"'|!4"))5!*a8"5 &{{=tDHNN:6$$ix%HI(4&<@ "9+.{{//C%%dFKK,<,# UHn[T5Ho!U4v M M g7frGr/rs rr7bMaskModuleTest.test_from_surface__with_colorkey_mask_pattern..alternate..rr2r/)func set_value unset_valuer9r:setbitrWs ` r alternateOMaskModuleTest.test_from_surface__with_colorkey_mask_pattern..alternates1FLe LSv);?#Mr)rrrs)rr;rG)rur rrr/rrN) r r!r rrar_rrarxrQrrb) ryr.r r r{rrzr/rr`rr!s r-test_from_surface__with_colorkey_mask_pattern   T]]_m A   TZZ\> ?   !!-8. %rc/SQnUHn[RRSSU5nURSS5 [RR USS5nUR 5nURUR5S5 URUR 5[R"S5/5 M UGHn[RRSSU5n[RRSSU5nURS 5 URS 5 URS S 5 [RR US SUS 9nURU[RR5 URUR5S5 URUR 5[R"S 5/5 GM g)z*Does mask.from_threshold() work correctly?rRrr)rGrGrrrrnrsrsrsrsrrrnr|rrrr|irrrr:r:rrrrr8)rcolorr othersurfacerN) r rr_rr!rrrQrar'rxr )ryr4rsurfr!rsurf2s rtest_from_threshold"MaskModuleTest.test_from_thresholds A>>))(Aq9D IIn&6 7;;--)+<D++-E   TZZ\3 /   T446EU9V8W XA>>))(Aq9DNN**8Q:E IIo & JJ ' JJ(8 9;;--"+" .D  ! !$ (8(8 9   TZZ\3 /   T446EU9V8W XrcSHn[RR[R"U55nUR U[RR SU35 UR UR5U5 M g)z?Ensures from_surface can create masks from zero sized surfaces.rrN)r r!rar_rxMaskTyperQrrs rtest_zero_size_from_surface*MaskModuleTest.test_zero_size_from_surfacesa0D;;++FNN4,@AD  ! !$ (<(<dVn M   T]]_d 3 1rc/SQnSnUGHnUHn[RRUSU5nURSS5 [RR USS5nUR UR5S5 UR5nUR U/5 M UGHn[RRUSU5n[RRUSU5nURS5 URS 5 URSS 5 [RR US SU5nURU[RR5 UR UR5S5 UR5nUR U/5 GM GM g) Nr3rrr4r5r6r7r8r9r;r8) r rr_rr!rrQrarrxr ) ryr4r6rrr>r!rr?s rtest_zero_size_from_threshold,MaskModuleTest.test_zero_size_from_thresholdsk ,D~~--dAq9 .*:;{{11-/@  q1//1  +~~--dAq9..tQ: /* ?+ ?,<={{11,(95%%dFKK,<,<=  q1//1  +rc|SnSnSn[R"U5nUHnURUS5 M [U5nSURS-nUH.nUupX-n UR XjU 4X-- S-SSUS35 M0 UH.nUupX-n UR XjU 4X-- S-SSUS 35 M0 g) N)ir)rj)rr)rQ)r/)rr)rJrOrr%z the pixel at z is not set to 1rz is not set to 0)r r r memoryviewstridesrQ) ryr pixels_set pixels_unsetr!pointviewintwidthrrcols rtest_buffer_interface$MaskModuleTest.test_buffer_interface s3 5 {{4 E KKq ! $t||A&EDA-C   1f!,/14w&67  "EDA-C   1f!,/14w&67 "rr2N)rqrrrsrtrr rr!r$r0r@rDrGrSrxr2rrrrs?.H`$LRhD6D4&P YD4,Brr__main__)r)rG)# collectionsrrplatformr rur r pygame.locals pygame.mathrpython_implementationrrr#r-r;r=rDrXr^rfTestCaserhr!r rzrrrrrvrrqmainr2rrr^s#    H224 4   IFN*( I[V?8$$[V?|l#fkk#'0a>x((a>H  :;oX&&o<od  z MMOr