
    xKgZ                        d dl Z d dlmZ d dlZd dlZd dlZd dlmZ d dlZ	d dl
mZmZ d dlmZmZmZmZ  edd      Zd Zd	 Zd
 Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Z d Z!d Z"d Z#d Z$d Z%d Z&d Z'd Z(d Z)d Z*d  Z+d! Z,d" Z-d# Z.d$ Z/d% Z0d& Z1d' Z2d( Z3d) Z4d* Z5d+ Z6d, Z7d- Z8 G d. d/ee      Z9 G d0 d1e9      Z: G d2 d3e9      Z; G d4 d5e;      Z< G d6 d7e;      Z= G d8 d9e;      Z> G d: d;e;      Z? G d< d=e;      Z@ G d> d?e9      ZA G d@ dAe9      ZB G dB dCe9      ZCeDdDk(  r e j                          yy)E    N)
namedtuple)TypingError)jitnjit)TestCaseenable_pyobj_flagsMemoryLeakMixincompile_functionPointabc                 f    | ddj                  d |D              iz  } t        d| t                     S )Ninitializerz, c              3   2   K   | ]  }t        |        y wN)repr).0args     Y/home/alanp/www/video.onchill/myenv/lib/python3.12/site-packages/numba/tests/test_sets.py	<genexpr>z-_build_set_literal_usecase.<locals>.<genexpr>   s     +F#DIs   	build_set)joinr
   globals)codeargss     r   _build_set_literal_usecaser      s1    =$))+F+F"FGGDKwy99    c                     d}t        ||       S )Nz@if 1:
    def build_set():
        return {%(initializer)s}
    r   r   r   s     r   set_literal_return_usecaser"      s    D &dD11r   c                     d}t        ||       S )Nz^if 1:
    def build_set():
        my_set = {%(initializer)s}
        return list(my_set)
    r    r!   s     r   set_literal_convert_usecaser$      s    D
 &dD11r   c                  N    t               } | j                  d       t        |       S N   )setaddlenss    r   empty_constructor_usecaser-   '   s    AEE!Hq6Mr   c                 .    t        |       }t        |      S r   )r(   r*   r   r,   s     r   constructor_usecaser0   ,   s    CAq6Mr   c                 P    t        |       }g }|D ]  }|j                  |        |S r   r(   append)r   r,   lvs       r   iterator_usecaser6   0   s*    CA
A	 Hr   c                     t               }|j                  |        |j                  |       |j                  |       t        |      S r   )r(   updatelist)r   r   cr,   s       r   update_usecaser;   7   s3    AHHQKHHQKHHQK7Nr   c                 4    t        | dd        }t        |      S r&   )r(   boolr/   s     r   bool_usecaser>   >   s    CGA7Nr   c                 ^    t        |       }|D ]  }|j                  |        t        |      S r   )r(   remover9   r   r   r,   r5   s       r   remove_usecaserB   C   s)    AA	 7Nr   c                 ^    t        |       }|D ]  }|j                  |        t        |      S r   )r(   discardr9   rA   s       r   discard_usecaserE   I   s)    AA			! 7Nr   c                     t        |       }t        d      D ]$  }|j                  |       |j                  |       & t	        |      S )Ni  )r(   ranger)   rD   r9   )r   ur5   r,   is        r   add_discard_usecaserJ   O   s:    AA4[	a			!  7Nr   c                     t        |       }g }t        |      dkD  r.|j                  |j                                t        |      dkD  r.|S Nr   )r(   r*   r3   pop)r   r,   r4   s      r   pop_usecaserN   V   s?    AA
A
a&1*	 a&1*Hr   c                 T    t        |       }g }|D ]  }|j                  ||v         |S r   r2   )r   r   r,   r4   r5   s        r   contains_usecaserP   ]   s/    AA
A	a Hr   c                 b    t        |       }|j                  t        |             t        |      S r   )r(   difference_updater9   r   r   r,   s      r   difference_update_usecaserT   d   s&    AAA7Nr   c                 b    t        |       }|j                  t        |             t        |      S r   )r(   intersection_updater9   rS   s      r   intersection_update_usecaserW   i   s&    AA#a&!7Nr   c                 b    t        |       }|j                  t        |             t        |      S r   )r(   symmetric_difference_updater9   rS   s      r   #symmetric_difference_update_usecaserZ   n   s&    AA!!#a&)7Nr   c                 H    t        |       j                  t        |            S r   )r(   
isdisjointr   s     r   isdisjoint_usecaser]   s       q6SV$$r   c                 H    t        |       j                  t        |            S r   )r(   issubsetr   s     r   issubset_usecasera   v   s    q6??3q6""r   c                 H    t        |       j                  t        |            S r   )r(   
issupersetr   s     r   issuperset_usecaserd   y   r^   r   c                 d    t        |       }|j                          t        |      t        |      fS r   )r(   clearr*   r9   r   r,   s     r   clear_usecaserh   |   s&    AAGGIq647?r   c                     t        |       }|j                         }|j                          t        |      t	        |      fS r   )r(   copyrM   r*   r9   r   r,   sss      r   copy_usecaserm      s2    AA	
BEEGr7DHr   c                     t        |       }|j                          |j                         }|j                  | d          t	        |      t        |      fS rL   )r(   rf   rj   r)   r*   r9   rk   s      r   copy_usecase_emptyro      sA    AAGGI	
BEE!A$Kr7DHr   c                     t        |       }|j                  |       |j                         }|j                          t	        |      t        |      fS r   )r(   r@   rj   rM   r*   r9   )r   r   r,   rl   s       r   copy_usecase_deletedrq      s=    AAHHQK	
BEEGr7DHr   c                 b    t        |       }|j                  t        |            }t        |      S r   )r(   
differencer9   r   r   sar,   s       r   difference_usecaserv      s&    	QB
c!fA7Nr   c                 b    t        |       }|j                  t        |            }t        |      S r   )r(   intersectionr9   rt   s       r   intersection_usecasery      s&    	QB
AA7Nr   c                 b    t        |       }|j                  t        |            }t        |      S r   )r(   symmetric_differencer9   rt   s       r   symmetric_difference_usecaser|      s(    	QB
A'A7Nr   c                 b    t        |       }|j                  t        |            }t        |      S r   )r(   unionr9   rt   s       r   union_usecaser      s&    	QB
QA7Nr   c                     t        |       }|S r   )r(   rg   s     r   set_return_usecaser      s    AAHr   c                      y r    )xs    r   noopr      s    r   c                 "    d}| D ]  }||z  }	 |S )z!
    Expect a set of numbers
    r   r   r   resr5   s      r   unbox_usecaser      s!     Cq Jr   c                 4    d}| D ]  }|t        |      z  } |S )z 
    Expect a set of tuples
    r   r*   r   s      r   unbox_usecase2r      s%     Cs1v Jr   c                 ,    | \  }}|}|D ]  }||z  }	 |S )z2
    Expect a (number, set of numbers) tuple.
    r   r   r   r   r   r5   s        r   unbox_usecase3r      s*     DAq
Cq Jr   c                 >    | \  }}|}|D ]  }|t        |      z  } |S )z1
    Expect a (number, set of tuples) tuple.
    r   r   s        r   unbox_usecase4r      s.     DAq
Cs1v Jr   c                 t    | j                  d       | j                  |       | t        |       t        |      fS N*   )r)   r8   r*   ru   sbs     r   reflect_simpler      s-    FF2JIIbMs2wBr   c                     t        |      dkD  rt        d      } | j                  d       | j                  |       t        d      }| j	                  |       | t        |       t        |      fS )Nr'   )g      &@g      6@g     @@g      F@g      E@)g     K@g     P@)r*   r(   r)   r8   rY   )ru   r   scs      r   reflect_conditionalr      sZ    
2w{%&FF3KIIbM	ZB""2&s2wBr   c                 0    | j                  d       t        r   )r)   ZeroDivisionErrorr+   s    r   reflect_exceptionr      s    EE"I
r   c                 H    | j                  |j                                | |u S r   )r)   rM   r   s     r   reflect_dualr      s    FF26688Or   c                 z    t               }g }| D ])  }||vs|j                  |       |j                  |       + |S r   )r(   r)   r3   )srcseenr   r5   s       r   unique_usecaser      s<    5D
CD=HHQKJJqM  Jr   c                   B     e Zd Z fdZd Zd Zd Zd Zd Zd Z	 xZ
S )BaseTestc                 ^    t         t        |           t        j                  d      | _        y r   )superr   setUprandomRandomrnd)self	__class__s    r   r   zBaseTest.setUp   s     h#%==$r   c                 Z    t        j                  t        |            j                         S r   )nparangeinttolistr   stops     r   _rangezBaseTest._range  s    yyT#**,,r   c                     t        |      D cg c]&  }| j                  j                  t        |            ( }}t	        |t
        j                        r!t        j                  ||j                        S |S c c}w )zD
        Choose *n* possibly duplicate items from sequence.
        dtype)	rG   r   choicer9   
isinstancer   ndarrayarrayr   )r   seqnrI   r4   s        r   _random_choicezBaseTest._random_choice  sZ     27q:ATXX__T#Y':c2::&88ASYY//H	 ;s   +A8c                 n    | j                  t        j                  |            }| j                  ||      S )z<
        Get a 1d array with many duplicate values.
        )r   r   sqrtr   r   r   r   s      r   duplicates_arrayzBaseTest.duplicates_array  s-     KK
#""1a((r   c                 N    | j                  |dz        }| j                  ||      S )z;
        Get a 1d array with values spread around.
        g?)r   r   r   s      r   sparse_arrayzBaseTest.sparse_array  s)    
 KKS!""1a((r   c                 X   t        |t              r=| j                  |t               t        ||      D ]  \  }}| j	                  ||        y t        |t
              r;| j                  |t
               | j                  t        |      t        |             y | j                  ||       y r   )r   tupleassertIsInstancezip_assert_equal_unorderedr9   assertPreciseEqualsorted)r   r   r   rH   r5   s        r   r   z BaseTest._assert_equal_unordered  s    a!!!U+Aq	1,,Q2 "4 !!!T*##F1Ivay9##Aq)r   c                 >      t        d             fd}|S )NTnopythonc                  >     |  } |  }j                  ||       y r   )r   )r   expectedgotcfuncpyfuncr   s      r   checkz)BaseTest.unordered_checker.<locals>.check*  s%    t}H,C((37r   r   r   r   r   r   s   `` @r   unordered_checkerzBaseTest.unordered_checker(  s     "T"6*	8 r   )__name__
__module____qualname__r   r   r   r   r   r   r   __classcell__)r   s   @r   r   r      s&    %-))	*r   r   c                   (    e Zd Zd Zd ZefdZd Zy)TestSetLiteralsc                 `    t        |      } |       } |       }| j                  ||       ||fS r   )r   r   )r   r   r   r   r   s        r   r   zTestSetLiterals.check3  s3    V8g#.H}r   c                 <    t        d      }| j                  |       y )N)r'         r   )r"   r   )r   r   s     r   test_build_setzTestSetLiterals.test_build_set:  s    +L9

6r   c                     t        d      }| j                  |       t        d      }| j                  |      \  }}| j                  t        |j	                               t        |j	                                      y )N)r'          @y              @r   )r   r   )r"   r   assertIstyperM   )r   flagsr   r   r   s        r   test_build_heterogeneous_setz,TestSetLiterals.test_build_heterogeneous_set>  sW    +O<

6+H5

6*Xd3779otHLLN';<r   c                     t        | j                  d            }t        |      } t        d      |      } |       } |       }| j	                  t        |      t        |             y )N2   Tr   )r9   r   r$   r   r   r   )r   r   r   r   r   r   s         r   test_build_set_nopythonz'TestSetLiterals.test_build_set_nopythonE  sY    4$$R(),S1"T"6*8gx 0&+>r   N)r   r   r   r   r   r   r   r   r   r   r   r   r   1  s     2D =?r   r   c                      e Zd Zd Zd Zd Zd Zd Zd Zd Z	d Z
d	 Zd
 Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Z d Z!d  Z"d! Z#d" Z$d# Z%d$ Z&d% Z'd& Z(d' Z)d( Z*d) Z+d* Z,d+ Z-y,)-TestSetsc                     t          t        d             j                                         t         t        d             fd} | j	                  d              | j                  d             y )NTr   c                 B    j                   |        |              y r   r   )r   r   r   r   s    r   r   z(TestSets.test_constructor.<locals>.checkX  s    ##F3Ks<r      )r-   r   r   r0   r   r   )r   r   r   r   s   ` @@r   test_constructorzTestSets.test_constructorQ  sp    *"T"6*2$"T"6*	= 	d##C()d$%r   c                     t         } t        d      |      }| j                  d      }| j                   ||      t	        |             y )NTr   r   )r   r   r   assertEqualr(   )r   r   r   r   s       r   test_set_returnzTestSets.test_set_return^  s@    #"T"6*##C(sSX.r   c                     t         }| j                  |      } || j                  d              || j                  d             y Nr   )r6   r   r   r   r   r   r   s      r   test_iteratorzTestSets.test_iteratore  s=    !&&v.d##C()d$%r   c                     t         }| j                  |      }| j                  d      }| j                  d      }| j                  d      } ||||       y Nr   )r;   r   r   r   )r   r   r   r   r   r:   s         r   test_updatezTestSets.test_updatel  sR    &&v.b!!!"%b!aAr   c                 v    t         }| j                  |      }| j                  d      }|d d d   } |||       y )Nr   
   )rB   r   r   r   r   r   r   r   s        r   test_removezTestSets.test_removeu  s=    &&v.b!ddGar   c                    | j                          t        } t        d      |      }t        t	        | j                  d                  }|dd  }|d   f}| j                  t              5   |||       d d d        y # 1 sw Y   y xY w)NTr   r   r'   r   )disable_leak_checkrB   r   r   r(   r   assertRaisesKeyError)r   r   r   itemsr   r   s         r   test_remove_errorzTestSets.test_remove_error}  sy    !"T"6* c$++A./0!"I1XKx(!QK )((s   ,
A??Bc                     t         }| j                  |      }| j                  d      }| j                  d      } |||       y r   )rE   r   r   r   s        r   test_discardzTestSets.test_discard  s@     &&v.b!b!ar   c                     t         }| j                  |      }dx}}||k(  r| j                  d      \  }}||k(  r ||f||       y)z
        Check that the insertion logic does not create an infinite lookup
        chain with deleted entries (insertion should happen at the first
        deleted entry, not at the free entry at the end of the chain).
        See issue #1913.
        Nr   )rJ   r   r   r   s        r   test_add_discardzTestSets.test_add_discard  sV     %&&v. A1f$$Q'DAq 1fqdAqr   c                 `    t         }| j                  |      } || j                  d             y r   )rN   r   r   r   s      r   test_popzTestSets.test_pop  s*    &&v.d#$r   c                      t          t        d             fd} j                  d      } j                  d      } |||       y )NTr   c                 F    j                   | |       | |             y r   r   r   r   r   r   r   s     r   r   z%TestSets.test_contains.<locals>.check      ##F1aL%1+>r   r   )rP   r   r   )r   r   r   r   r   r   s   `   @@r   test_containszTestSets.test_contains  sI    !"T"6*	? b!b!ar   c                     | j                  |      }d}t        j                  ||      D ]0  \  }}| j                  |      }| j                  |      } |||       2 y )Nr'   r   i  r   	itertoolsproductr   )r   r   r   sizesnanbr   r   s           r   _test_xxx_updatezTestSets._test_xxx_update  s[    &&v.''u5FB!!"%A!!"%A!QK 6r   c                 .    | j                  t               y r   )r  rT   r   s    r   test_difference_updatezTestSets.test_difference_update  s    78r   c                 .    | j                  t               y r   )r  rW   r  s    r   test_intersection_updatez!TestSets.test_intersection_update  s    9:r   c                 .    | j                  t               y r   )r  rZ   r  s    r    test_symmetric_difference_updatez)TestSets.test_symmetric_difference_update  s    ABr   c                 N     t        d             fd}t        t         j                  d       j                  d      g      \  }}||z  ||z
  ||z  ||z  g}|D cg c]  }t	        |       }}t        j                  ||      D ]  \  }} |||        y c c}w )NTr   c                 F    j                   | |       | |             y r   r   r  s     r   r   z(TestSets._test_comparator.<locals>.check  r  r   r      )r   mapr(   r   r   r  r  )r   r   r   r   r   r   r   r   s   ``     @r   _test_comparatorzTestSets._test_comparator  s    "T"6*	? 3**2.0A0A"0EFG1Aq1ua!eQU+"&'$Qa$'%%dD1DAq!QK 2 (s   &B"c                 .    | j                  t               y r   )r'  r]   r  s    r   test_isdisjointzTestSets.test_isdisjoint      01r   c                 .    | j                  t               y r   )r'  ra   r  s    r   test_issubsetzTestSets.test_issubset  s    ./r   c                 .    | j                  t               y r   )r'  rd   r  s    r   test_issupersetzTestSets.test_issuperset  r*  r   c                 `    t         }| j                  |      } || j                  d             y r   )rh   r   r   r   s      r   
test_clearzTestSets.test_clear  s*    &&v.d#$r   c                 R   t         }| j                  |      } || j                  d             t        }| j                  |      }| j                  d      } ||       t        }| j                  |      } |dd       | j                  d      } |||t        |      dz            y )Nr   r'   r'   r         r   )rm   r   r   ro   rq   r*   )r   r   r   r   s       r   	test_copyzTestSets.test_copy  s    &&v.d#$#&&v.a a &&&v.mQb!a3q6Q; r   c                     t         }| j                  |      } || j                  d              || j                  d             y )Nr'   r   )r>   r   r   r   s      r   	test_boolzTestSets.test_bool  s=    &&v.d"#d"#r   c                     | j                  |      }d\  }} |||       d}t        j                  ||      D ]0  \  }}| j                  |      }| j                  |      } |||       2 y )N)r2  )r   r      r4  r   r  r  )r   r   r   r   r   r  r  r  s           r   _test_set_operatorzTestSets._test_set_operator  sm    &&v./1a''u5FB!!"%A!!"%A!QK 6r   c                 J    dt        |      z  }t        d|t                     S )Nzrif 1:
        def operator_usecase(a, b):
            s = set(a) %(op)s set(b)
            return list(s)
        opoperator_usecasedictr
   r   r   r=  r   s      r   make_operator_usecasezTestSets.make_operator_usecase  +     bk	
   2D')DDr   c                 J    dt        |      z  }t        d|t                     S )Nzif 1:
        def inplace_operator_usecase(a, b):
            sa = set(a)
            sb = set(b)
            sc = sa
            sc %(op)s sb
            return list(sc), list(sa)
        r<  inplace_operator_usecaser?  rA  s      r   make_inplace_operator_usecasez&TestSets.make_inplace_operator_usecase  +     bk   :D')LLr   c                 J    dt        |      z  }t        d|t                     S )Nz\if 1:
        def comparison_usecase(a, b):
            return set(a) %(op)s set(b)
        r<  comparison_usecaser?  rA  s      r   make_comparison_usecasez TestSets.make_comparison_usecase  +     bk   4dGIFFr   c                 .    | j                  t               y r   )r:  rv   r  s    r   test_differencezTestSets.test_difference  s     23r   c                 .    | j                  t               y r   )r:  ry   r  s    r   test_intersectionzTestSets.test_intersection!  s     45r   c                 .    | j                  t               y r   )r:  r|   r  s    r   test_symmetric_differencez"TestSets.test_symmetric_difference$  s     <=r   c                 .    | j                  t               y r   )r:  r   r  s    r   
test_unionzTestSets.test_union'  s    .r   c                 D    | j                  | j                  d             y )N&r:  rB  r  s    r   test_andzTestSets.test_and*       : :3 ?@r   c                 D    | j                  | j                  d             y )N|rV  r  s    r   test_orzTestSets.test_or-  rX  r   c                 D    | j                  | j                  d             y )N-rV  r  s    r   test_subzTestSets.test_sub0  rX  r   c                 D    | j                  | j                  d             y )N^rV  r  s    r   test_xorzTestSets.test_xor3  rX  r   c                 D    | j                  | j                  d             y )Nz==r:  rJ  r  s    r   test_eqzTestSets.test_eq6       < <T BCr   c                 D    | j                  | j                  d             y )Nz!=rc  r  s    r   test_nezTestSets.test_ne9  re  r   c                 D    | j                  | j                  d             y )Nz<=rc  r  s    r   test_lezTestSets.test_le<  re  r   c                 D    | j                  | j                  d             y )N<rc  r  s    r   test_ltzTestSets.test_lt?       < <S ABr   c                 D    | j                  | j                  d             y )Nz>=rc  r  s    r   test_gezTestSets.test_geB  re  r   c                 D    | j                  | j                  d             y )N>rc  r  s    r   test_gtzTestSets.test_gtE  rm  r   c                 D    | j                  | j                  d             y )Nz&=r:  rF  r  s    r   	test_iandzTestSets.test_iandH       B B4 HIr   c                 D    | j                  | j                  d             y )Nz|=rt  r  s    r   test_iorzTestSets.test_iorK  rv  r   c                 D    | j                  | j                  d             y )Nz-=rt  r  s    r   	test_isubzTestSets.test_isubN  rv  r   c                 D    | j                  | j                  d             y )Nz^=rt  r  s    r   	test_ixorzTestSets.test_ixorQ  rv  r   N).r   r   r   r   r   r   r   r  r  r	  r  r  r  r  r  r   r"  r'  r)  r,  r.  r0  r5  r7  r:  rB  rF  rJ  rM  rO  rQ  rS  rW  r[  r^  ra  rd  rg  ri  rl  ro  rr  ru  rx  rz  r|  r   r   r   r   r   O  s    &/& %9;C	202%!$$
E	MG46>/AAAADDDCDCJJJJr   r   c                       e Zd ZdZd Zy)TestFloatSetsz-
    Test sets with floating-point keys.
    c                 x    t        j                  |t         j                        t        j                  d      z  S )Nr   g?)r   r   float32r   s     r   r   zTestFloatSets._range\  s$    yyRZZ02::c?BBr   Nr   r   r   __doc__r   r   r   r   r~  r~  U  s    Cr   r~  c                       e Zd ZdZd Zy)TestTupleSetsz$
    Test sets with tuple keys.
    c                    t        j                  |t         j                        }|dz  }|dz  j                  t         j                        }|dz	  dz  j                  t         j
                        }t        t        |||            S )Nr   l   UU*UU* l   *UU     r'   )r   r   int64astypeint32bool_r9   r   )r   r   r   r   r:   ds         r   r   zTestTupleSets._ranged  sh    IId"((+""^##BHH-2g]""288,C1aL!!r   Nr  r   r   r   r  r  `  s    "r   r  c                       e Zd ZdZd Zy)TestUnicodeSetszR
    Test sets with unicode keys. For the purpose of testing refcounted sets.
    c                 n    t        t        |            D cg c]  }dj                  |       c}S c c}w )NzA{})rG   r   format)r   r   rI   s      r   r   zTestUnicodeSets._rangep  s-    ).s4y)9:)9AQ)9:::s   2Nr  r   r   r   r  r  l  s    ;r   r  c                       e Zd Zd Zy)TestSetsInvalidDtypec                      t        d      |      }t        g d      }t        g d      }d}| j                  t        |      5   |||       d d d        y # 1 sw Y   y xY w)NTr   r2  )r   r   r:   z!All Sets must be of the same typer   r(   assertRaisesRegexr   r   r   r   r   r   msgs         r   r:  z'TestSetsInvalidDtype._test_set_operatorv  sS     #T"6* 1##K5!QK 655s   
AA!N)r   r   r   r:  r   r   r   r  r  t  s    	r   r  c                   T    e Zd Zd Zd Zd Zd Zd Zd Zd Z	d Z
d	 Zd
 Zd Zd Zy)TestSetsInvalidc                 :    | j                  |      }t        |      S r   )r{   r9   rS   s      r   r|   z,TestSetsInvalid.symmetric_difference_usecase  s    ""1%Awr   c                 :    | j                  |      }t        |      S r   )rs   r9   rS   s      r   rv   z"TestSetsInvalid.difference_usecase  s    LLOAwr   c                 :    | j                  |      }t        |      S r   )rx   r9   rS   s      r   ry   z$TestSetsInvalid.intersection_usecase  s    NN1Awr   c                 :    | j                  |      }t        |      S r   )r~   r9   rS   s      r   r   zTestSetsInvalid.union_usecase  s    GGAJAwr   c                      t        d      |      }t        g d      }d}d}| j                  t        |      5   |||       d d d        y # 1 sw Y   y xY w)NTr   r2  r'   r   r   zAll arguments must be Setsr  r  s         r   r:  z"TestSetsInvalid._test_set_operator  sN     #T"6**##K5!QK 655s   
AAc                 B    | j                  t        j                         y r   )r:  r  rv   r  s    r   rM  zTestSetsInvalid.test_difference  s     B BCr   c                 B    | j                  t        j                         y r   )r:  r  ry   r  s    r   rO  z!TestSetsInvalid.test_intersection  s     D DEr   c                 B    | j                  t        j                         y r   )r:  r  r|   r  s    r   rQ  z)TestSetsInvalid.test_symmetric_difference  s     L LMr   c                 B    | j                  t        j                         y r   )r:  r  r   r  s    r   rS  zTestSetsInvalid.test_union  s     = =>r   c                 J    dt        |      z  }t        d|t                     S )Nzhif 1:
        def operator_usecase(a, b):
            s = a %(op)s b
            return list(s)
        r<  r>  r?  rA  s      r   rB  z%TestSetsInvalid.make_operator_usecase  rC  r   c                 J    dt        |      z  }t        d|t                     S )Nzif 1:
        def inplace_operator_usecase(a, b):
            sa = a
            sb = b
            sc = sa
            sc %(op)s sb
            return list(sc), list(sa)
        r<  rE  r?  rA  s      r   rF  z-TestSetsInvalid.make_inplace_operator_usecase  rG  r   c                 J    dt        |      z  }t        d|t                     S )NzWif 1:
        def comparison_usecase(a, b):
            return set(a) %(op)s b
        r<  rI  r?  rA  s      r   rJ  z'TestSetsInvalid.make_comparison_usecase  rK  r   N)r   r   r   r|   rv   ry   r   r:  rM  rO  rQ  rS  rB  rF  rJ  r   r   r   r  r    sD    	DFN?E	MGr   r  c                   X    e Zd ZdZej
                  d        Zd Zd Zd Z	d Z
d Zd Zy	)
TestUnboxingz>
    Test unboxing of Python sets into native Numba sets.
    c              #      K   | j                  t              5 }d  d d d        |&| j                  t        j                        |       y y # 1 sw Y   2xY wwr   )r  	TypeErrorassertRegexstr	exception)r   r  raisess      r   assert_type_errorzTestUnboxing.assert_type_error  sK     y)V *?S!1!12C8  *)s   AA1AAAc                 >      t        d             fd}|S )NTr   c                 J     |       } |       }j                  ||       y r   r   )r   r   r   r   r   r   s      r   r   z'TestUnboxing.check_unary.<locals>.check  s%    c{H*C##C2r   r   r   s   `` @r   check_unaryzTestUnboxing.check_unary  s     "T"6*	3 r   c                     | j                  t              } |t        ddg              |t        ddg              |t        t        d                   y )Nr'   r   y              ?y              @d   )r  r   r(   rG   r   r   s     r   test_numberszTestUnboxing.test_numbers  sB      /c1a&kc2t*oc%*or   c                 z    | j                  t              } |t        ddg              |t        ddg             y )N)r'   r   )r   r3  )r'                  @)r   y              @)r  r   r(   r  s     r   test_tupleszTestUnboxing.test_tuples  s6      0c66"#$c7G$%&r   c                 X    | j                  t              } |dt        g d      f       y )Nr'   )r   r   r3  )r  r   r(   r  s     r   test_set_inside_tuplez"TestUnboxing.test_set_inside_tuple  s#      0q#i.!"r   c                 X    | j                  t              } |dt        ddg      f       y )Nr'   )r   )r   )r  r   r(   r  s     r   test_set_of_tuples_inside_tuplez,TestUnboxing.test_set_of_tuples_inside_tuple  s(      0q#tTl#$%r   c           
         d}t         } t        d      |      }t        ddg      }| j                  |      5   ||       d d d        | j	                  |t        ddg             | j                  |      5   |t        ddg             d d d        | j                  |      5   |dt        ddg      f       d d d        | j                  |      5   |t        dt        ddg                   d d d        t        ddg      }| j                  t        t        f      5 } ||       d d d        y # 1 sw Y   xY w# 1 sw Y   xY w# 1 sw Y   xY w# 1 sw Y   gxY w# 1 sw Y   y xY w)	Nzcan't unbox heterogeneous setTr   r'   g      @r  )r'   )r   r   )	r   r   r(   r  r   r   r  
IndexError
ValueError)r   r  r   r   vallstr  s          r   test_errorszTestUnboxing.test_errors  s6   -"T"6*1c(m##C(#J ) 	c1c(m,##C(#q"g, ) ##C(1c1b'l#$ )##C(%32w<() ) 4.! 
J78F#J 98! )( )( )((( 98s;   	D48E %EE"	E$4D= E	EE!$E-N)r   r   r   r  
contextlibcontextmanagerr  r  r  r  r  r  r  r   r   r   r  r    s?     9 9'
#&r   r  c                   4    e Zd ZdZd Zd Zd Zd Zd Zd Z	y)	TestSetReflectionzE
    Test reflection of native Numba sets on Python set objects.
    c                     t        d      |      }t        g d      t        dg      ft        g d      t        g d      fg}|D ]  \  }}t        |      }t        |      } |||      }| j                  ||      5   |||      }	| j                  |	|       | j                  ||       | j	                  |d   |u |	d   |u        ~~	d d d         y # 1 sw Y   xY w)NTr   )g      ?r   g      @g      @g        )g      @g      @g      @g       @g      "@r   )r   r(   assertRefCountr   r   )
r   r   r   samplesdestr   r   r   pyrescress
             r   check_reflectionz"TestSetReflection.check_reflection  s    "T"6*()3t95()3/C+DE !ID#4yHd)C8S)E$$S#.S#''e4''#6  qX!5tAw#~F4 /.	 ! /.s   ?ACC	c                 .    | j                  t               y r   )r  r   r  s    r   test_reflect_simplez%TestSetReflection.test_reflect_simple  s    n-r   c                 .    | j                  t               y r   )r  r   r  s    r   test_reflect_conditionalz*TestSetReflection.test_reflect_conditional   s    12r   c                 8   t         } t        d      |      }t        g d      }| j                  |      5  | j	                  t
              5   ||       ddd       | j                  |t        g d             ddd       y# 1 sw Y   /xY w# 1 sw Y   yxY w)zd
        When the function exits with an exception, sets should still be
        reflected.
        Tr   r  N)r'   r   r   r   )r   r   r(   r  r  r   r   )r   r   r   r,   s       r   test_reflect_exceptionz(TestSetReflection.test_reflect_exception#  sy    
 #"T"6*	N  #""#45a 6##As='9: $#55 $#s#   B	B%BB		BBc                     t         } t        d      |      }t        g d      }|j                         } |||      } |||      }| j	                  ||       | j	                  ||       | j                  ||       y)zf
        When the same set object is reflected twice, behaviour should
        be consistent.
        Tr   r  N)r   r   r(   rj   r   assertRefCountEqual)r   r   r   pysetcsetr   r   s          r   test_reflect_same_setz'TestSetReflection.test_reflect_same_set0  sv    
 "T"6*Izz|%'D$#.t,  -r   c                      t        d      t              }t        dg      }|D cg c]  }t        |       }} ||       | j	                  |D cg c]  }t        |       c}|       yc c}w c c}w )zO
        When the set wasn't mutated, no reflection should take place.
        Tr   y              )@N)r   r   r(   idr   )r   r   r,   r   idss        r   test_reflect_cleanz$TestSetReflection.test_reflect_clean?  sj     #T"4(L ar!ua a+A"Q%+S1 !+s   A-A2N)
r   r   r   r  r  r  r  r  r  r  r   r   r   r  r    s%      .3;.	2r   r  c                       e Zd ZdZd Zd Zy)TestExamplesz!
    Examples of using sets.
    c                     t         }| j                  |      } || j                  d              || j                  d             y r   )r   r   r   r   r   s      r   test_uniquezTestExamples.test_uniqueP  s=    &&v.d##C()d$%r   c                 :    d }| j                  |      } |        y )Nc                      t        j                  d      } t               }|j                  h d       |j	                  |        |S )Nr'   >   r'   r   r   )r   uint64r(   r8   r)   )rI   Rs     r   implz9TestExamples.test_type_coercion_from_update.<locals>.implY  s2    		!AAHHYEE!HHr   )r   )r   r  r   s      r   test_type_coercion_from_updatez+TestExamples.test_type_coercion_from_updateW  s    	 &&t,r   N)r   r   r   r  r  r  r   r   r   r  r  K  s    &	r   r  __main__)Funittestcollectionsr   r  r  r   numba.core.errorsr   numpyr   numbar   r   numba.tests.supportr   r   r	   r
   r   r   r"   r$   r-   r0   r6   r;   r>   rB   rE   rJ   rN   rP   rT   rW   rZ   r]   ra   rd   rh   rm   ro   rq   rv   ry   r|   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r~  r  r  r  r  r  r  r  r   mainr   r   r   <module>r     s    "    )  3 3 	7J':22




%#%





	 
	 
3 3l?h ?<CJx CJLCH C	"H 	";h ;8 AGh AGH?8 ?D@2 @2F8 0 zHMMO r   