
\K]c           @  s  d  Z  d d l m Z d d l Z d d l Z d d l Z d d l Z d d l Z d d l Z d d l	 Z	 d d l
 Z
 d d l Z d d l Z d d l Z d d l Z d d l Z d d l Z d d l Z d d l Z d d l m Z m Z m Z m Z m Z m Z d d l m Z m Z m Z m  Z  d d l! m" Z" d d l# j$ Z% d d l& m' Z' e   Z( e( j) d  e   Z* e* j) d	  e   Z+ e   Z, e, j) d
  e j- d d g  Z. e j/ j0 d  oe j1 d  d d f k Z2 e j3 d d k Z4 d Z5 e% j6 e4 pe2 e5  Z7 d e8 f d     YZ9 d e% j: f d     YZ: d e8 f d     YZ; e j< d    Z= e j< d    Z> d   Z? e@ e@ d  ZA d ZB e	 jC d k re	 jD jE e jF   eB  ZB n+ e	 jD jE e jF   d eB e	 jG   f  ZB d d  ZH d!   ZI d"   ZJ d#   ZK d$   ZL d%   ZM e j< d&    ZN d'   ZO d(   ZP e j< d)    ZQ d* e8 f d+     YZR d, eR f d-     YZS e j< d.    ZT e j< d/    ZU d0   ZV eW eX d1  ZY d2   ZZ d S(3   s&   
Assorted utilities for use in tests.
i(   t   print_functionN(   t   configt   errorst   typingt   utilst   numpy_supportt   testing(   t   compile_extrat   compile_isolatedt   Flagst   DEFAULT_FLAGS(   t   cpu(   t   rtsyst   enable_pyobjectt   force_pyobjectt   nrtt	   importantt   long_runningt   win32i   i   i    s   parfors not supportedt   CompilationCachec           B  s&   e  Z d  Z d   Z d e d  Z RS(   s   
    A cache of compilation results for various signatures and flags.
    This can make tests significantly faster (or less slow).
    c         C  s1   t  j   |  _ t j |  j  |  _ i  |  _ d  S(   N(   R   t   Contextt	   typingctxR   t
   CPUContextt	   targetctxt   cr_cache(   t   self(    (    s2   lib/python2.7/site-packages/numba/tests/support.pyt   __init__:   s    c         C  s   d d l  m } | | | | f } y |  j | } Wnd t k
 r | j |  j |  j  , t |  j |  j | | | | d i  } Wd QX| |  j | <n X| S(   se   
        Compile the function or retrieve an already compiled result
        from the cache.
        i(   t
   cpu_targett   localsN(   t   numba.targets.registryR   R   t   KeyErrort   nested_contextR   R   R   (   R   t   funct   argst   return_typet   flagsR   t	   cache_keyt   cr(    (    s2   lib/python2.7/site-packages/numba/tests/support.pyt   compile?   s    N(   t   __name__t
   __module__t   __doc__R   t   NoneR
   R&   (    (    (    s2   lib/python2.7/site-packages/numba/tests/support.pyR   4   s   	t   TestCasec           B  s4  e  Z e Z e j d     Z d   Z e j	 d    Z
 e j	 d    Z e j	 d    Z e e j f Z e e j e f e j f e j g Z e f e f e j g Z e e f g Z e e j f Z e e j f Z  d   Z! d   Z" d   Z# d   Z$ d	 d
 d e& d d  Z' d	 d
 d e& d d  Z( d   Z) RS(   c         C  s   t  j j d  S(   Ni*   (   t   npt   randomt   RandomState(   R   (    (    s2   lib/python2.7/site-packages/numba/tests/support.pyR-   Y   s    c         C  sA   t  | t  r t j | } n  y
 | ` Wn t k
 r< n Xd S(   s   
        Reset the warnings registry of a module.  This can be necessary
        as the warnings module is buggy in that regard.
        See http://bugs.python.org/issue4180
        N(   t
   isinstancet   strt   syst   modulest   __warningregistry__t   AttributeError(   R   t   module(    (    s2   lib/python2.7/site-packages/numba/tests/support.pyt   reset_module_warnings]   s    
c         c  s9   t  j t  j t t f } |  j |   } | VWd QXd S(   sr   
        A context manager that asserts the enclosed code block fails
        compiling in nopython mode.
        N(   R   t   LoweringErrort   TypingErrort	   TypeErrort   NotImplementedErrort   assertRaises(   R   t   _accepted_errorst   cm(    (    s2   lib/python2.7/site-packages/numba/tests/support.pyt   assertTypingErrorj   s    c         g  s   g  | D] } t  j |  ^ q } d Vg  | D] } t  j |  ^ q. } xL t | | |  D]8 \ } } } | | k r\ |  j d | | | f  q\ q\ Wd S(   s   
        A context manager that asserts the given objects have the
        same reference counts before and after executing the
        enclosed block.
        Ns-   Refcount changed from %d to %d for object: %r(   R1   t   getrefcountt   zipt   fail(   R   t   objectst   xt   old_refcountst   new_refcountst   oldt   newt   obj(    (    s2   lib/python2.7/site-packages/numba/tests/support.pyt   assertRefCountu   s    """	c         c  s   t  j   } d Vt  j   } | j | j } | j | j } | j | j } | j | j } |  j | | d  |  j | | d  d S(   s|   
        A context manager that asserts no NRT leak was created during
        the execution of the enclosed block.
        Ns-   number of data allocs != number of data freess3   number of meminfo allocs != number of meminfo frees(   R   t   get_allocation_statst   alloct   freet   mi_alloct   mi_freet   assertEqual(   R   RF   RG   t   total_alloct
   total_freet   total_mi_alloct   total_mi_free(    (    s2   lib/python2.7/site-packages/numba/tests/support.pyt   assertNoNRTLeak   s    c         C  s   t  | t j  r d St  | t j  r, d Sx$ |  j D] } t  | |  r6 d Sq6 Wx$ |  j D] } t  | |  r] d Sq] Wx$ |  j D] } t  | |  r d Sq Wx$ |  j D] } t  | |  r d Sq Wd S(   s   
        This function returns a string description of the type family
        that the object in question belongs to.  Possible return values
        are: "exact", "complex", "approximate", "sequence", and "unknown"
        t   ndarrayt   enumt   sequencet   exactt   complext   approximatet   unknown(	   R/   R,   RU   RV   t   Enumt   _sequence_typesetst   _exact_typesetst   _complex_typest   _approx_typesets(   R   t   numeric_objectt   tp(    (    s2   lib/python2.7/site-packages/numba/tests/support.pyt   _detect_family   s"    c         C  sH   t  j d k r@ t  j d k r@ | t j d  k r@ t j d  S| Sd S(   s7   
        Fix the given *dtype* for comparison.
        R   i   i    t   int32t   int64NI       (   R1   t   platformt   maxsizeR,   t   dtype(   R   Rh   (    (    s2   lib/python2.7/site-packages/numba/tests/support.pyt
   _fix_dtype   s    c         C  s`   | j  d k r d g | j Sg  t | j | j  D]% \ } } | d k r3 | | j ^ q3 Sd S(   s   
        Return the strides of the given array, fixed for comparison.
        Strides for 0- or 1-sized dimensions are ignored.
        i    i   N(   t   sizet   ndimR@   t   stridest   shapet   itemsize(   R   t   arrt   strideRm   (    (    s2   lib/python2.7/site-packages/numba/tests/support.pyt   _fix_strides   s
    c         C  s[   |  j  | j | j d  |  j  | j | j d  |  j  |  j |  |  j |  d  d S(   sG   
        Test that two arrays have the same shape and strides.
        s   shapes differs   itemsizes differs   strides differN(   RO   Rm   Rn   Rq   (   R   t   firstt   second(    (    s2   lib/python2.7/site-packages/numba/tests/support.pyt   assertStridesEqual   s    RX   i   c   
      C  sg   y# |  j  | | | | | | |  Wn t k
 rD } t |  }	 n Xd S|  j d | | |	 f  d S(   sg  
        Versatile equality testing function with more built-in checks than
        standard assertEqual().

        For arrays, test that layout, dtype, shape are identical, and
        recursively call assertPreciseEqual() on the contents.

        For other sequences, recursively call assertPreciseEqual() on
        the contents.

        For scalars, test that two scalars or have similar types and are
        equal up to a computed precision.
        If the scalars are instances of exact types or if *prec* is
        'exact', they are compared exactly.
        If the scalars are instances of inexact types (float, complex)
        and *prec* is not 'exact', then the number of significant bits
        is computed according to the value of *prec*: 53 bits if *prec*
        is 'double', 24 bits if *prec* is single.  This number of bits
        can be lowered by raising the *ulps* value.
        ignore_sign_on_zero can be set to True if zeros are to be considered
        equal regardless of their sign bit.
        abs_tol if this is set to a float value its value is used in the
        following. If, however, this is set to the string "eps" then machine
        precision of the type(first) is used in the following instead. This
        kwarg is used to check if the absolute difference in value between first
        and second is less than the value set, if so the numbers being compared
        are considered equal. (This is to handle small numbers typically of
        magnitude less than machine precision).

        Any value of *prec* other than 'exact', 'single' or 'double'
        will raise an error.
        Ns   when comparing %s and %s: %s(   t   _assertPreciseEqualt   AssertionErrorR0   RA   (
   R   Rr   Rs   t   prect   ulpst   msgt   ignore_sign_on_zerot   abs_tolt   exct   failure_msg(    (    s2   lib/python2.7/site-packages/numba/tests/support.pyt   assertPreciseEqual   s    $c      	     s  d
     f d  }  j |  }	  j |  }
 d |	 |
 f }  r` | d  f 7} n   j |	 |
 d | |	 } | d k r j | j  }  j |  j | j    j | j | j d   j | j | j d   j | j j | j j d   j  j	 |   j	 |  d	  | j | k rM| j
 |  } n  | j | k rn| j
 |  } n  xB t | j | j  D]+ \ } }  j | | | |    |  qWd
 S| d k r( j t |  t |  d  x< t | |  D]+ \ } }  j | | | |    |  qWd
 S| d k r=t } n | d k rRt } n | d k r j | j | j   j | j | j | |    |  d
 S| d k r j | j | j  t } n d st d   t | d  rt | d  r j | j | j  n  t |  j  t |  j  k rud | j | j f }  re| d  f 7} n   j |  n  y& t j |  rt j |  rd
 SWn t k
 rn X| d
 k	 r'| d k rt j t |   j } n( t | t   r| } n t! d |   t" | |  | k  r'd
 Sn  | p6| d k } | r| d k r| d k rad } n( | d k rvd } n t! d | f   d | | d } | t" |  t" |  } n d
 } t |  j#  r| | j$ | j$ |  | | j% | j% |  n t | t j& t j' f  rpt( j) d  k r]t j* |  r] j t j* |  t j* |   q| | | |  n | | | |  d
 S(!   s-   Recursive workhorse for assertPreciseEqual().c           s   | d  k sF |  | k o# d k n sF t j |   sF t j |  r  j |  | d    s yN t j d |   t j d |  k r  j  j  d |  | f   n  Wq t k
 r q Xq n  j |  | d | d  d  S(   Ng        Ry   i   s   %s != %st   delta(	   R*   t   matht   isinfRO   t   copysignRA   t   _formatMessageR9   t   assertAlmostEqual(   Rr   Rs   R   (   Rz   Ry   R   (    s2   lib/python2.7/site-packages/numba/tests/support.pyt   _assertNumberEqual  s    ($	
s    Type Family mismatch. (%s != %s)s   : %sRy   RU   s   different number of dimensionss   different shapess   different mutabilitys   different stridesNRW   RX   RY   RZ   RV   R[   i    s   unexpected familyRh   s$   Mismatching return types (%s vs. %s)t   epss)   abs_tol is not "eps" or a float, found %st   singlei   t   doublei5   s   unsupported precision %ri   i   i   (   RY   RZ   (   i   i   (+   R*   Rc   RO   Ri   Rh   Rk   Rm   R#   t	   writeableRq   t   astypeR@   t   flatRu   t   lent   Truet   Falset   assertIst	   __class__t   valueRv   t   hasattrR/   t   _bool_typesRA   t   cmatht   isnanR9   R,   t   finfot   typeR   t   floatt
   ValueErrort   absR_   t   realt   imagt   timedelta64t
   datetime64R   t   versiont   isnat(   R   Rr   Rs   Rw   Rx   Ry   Rz   R{   R   t   first_familyt   second_familyt   assertion_messaget   compare_familyRh   t   at   bt   exact_comparisont   rtolt   bitst   kR   (    (   Rz   Ry   R   s2   lib/python2.7/site-packages/numba/tests/support.pyRu     s    
""			
		
		%c         C  sJ   t  | d d | } | j } |   } |   } |  j | |  | | f S(   s   
        Compile the 0-argument *pyfunc* with the given *flags*, and check
        it returns the same result as the pure Python function.
        The got and expected results are returned.
        R#   (    (   R   t   entry_pointR~   (   R   t   pyfuncR#   R%   t   cfunct   expectedt   got(    (    s2   lib/python2.7/site-packages/numba/tests/support.pyt   run_nullary_func  s    			N(*   R'   R(   R   t   longMessageR   t   cached_propertyR-   R6   t
   contextlibt   contextmanagerR>   RI   RT   t   boolR,   t   bool_R   t	   INT_TYPESR0   t   integert	   text_typeR^   R   RY   t   inexactR`   t   tuplet   listR]   t   floatingt   _float_typest   complexfloatingR_   Rc   Ri   Rq   Rt   R*   R   R~   Ru   R   (    (    (    s2   lib/python2.7/site-packages/numba/tests/support.pyR+   S   s.   	$					.t   SerialMixinc           B  s   e  Z d  Z e Z RS(   s-   Mixin to mark test for serial execution.
    (   R'   R(   R)   R   t   _numba_parallel_test_(    (    (    s2   lib/python2.7/site-packages/numba/tests/support.pyR     s   c         c  s@   t  t |   } t t |  |  z	 d VWd t t |  |  Xd S(   s   
    Return a context manager that temporarily sets Numba config variable
    *name* to *value*.  *name* must be the name of an existing variable
    in numba.config.
    N(   t   getattrR   t   setattr(   t   nameR   t	   old_value(    (    s2   lib/python2.7/site-packages/numba/tests/support.pyt   override_config  s
    	c         c  sj   t  j j |   } | t  j |  <t j   z	 d VWd | d k rN t  j |  =n | t  j |  <t j   Xd S(   sk   
    Return a context manager that temporarily sets an Numba config environment
    *name* to *value*.
    N(   t   ost   environt   getR   t   reload_configR*   (   R   R   RF   (    (    s2   lib/python2.7/site-packages/numba/tests/support.pyt   override_env_config  s    
	c         C  s6   t  | j   d d  } i  } t | | |  | |  S(   sj   
    Given a *code* string, compile it with globals *globs* and return
    the function named *name*.
    s   <string>R   (   R&   t   rstript   eval(   R   t   codet   globst   cot   ns(    (    s2   lib/python2.7/site-packages/numba/tests/support.pyt   compile_function  s    c         C  s   |  j  } t |  } | d k r- | j } n  | d k rE | j } n  t j d k r | | j | j | j	 | j
 | j | | | j | j | j | j | j | j  } nK | | j | j	 | j
 | j | | | j | j | j | j | j | j  } | |  _  d S(   s   
    Tweak the code object of the given function by replacing its
    *codestring* (a bytes object) and *consts* tuple, optionally.
    i   N(   i   (   t   __code__R   R*   t   co_codet	   co_constsR1   t   version_infot   co_argcountt   co_kwonlyargcountt
   co_nlocalst   co_stacksizet   co_flagst   co_namest   co_varnamest   co_filenamet   co_namet   co_firstlinenot	   co_lnotab(   R    t
   codestringt   constsR   Rb   t   new_code(    (    s2   lib/python2.7/site-packages/numba/tests/support.pyt
   tweak_code  s$    	s   numba-testst   nts   %s.%si   i  c          C  sC   y t  j t  Wn+ t k
 r> }  |  j t j k r?   q? n Xd  S(   N(   R   t   mkdirt   _trashcan_dirt   OSErrort   errnot   EEXIST(   t   e(    (    s2   lib/python2.7/site-packages/numba/tests/support.pyt   _create_trashcan_dir  s
    c          C  s   t  j    t }  x t t j t   D]i } t j j t |  } y8 t j |  } | j	 |  k  rx t
 j | d t n  Wq& t k
 r } q& Xq& Wd  S(   Nt   ignore_errors(   t   timet   _trashcan_timeoutt   sortedR   t   listdirR   t   patht   joint   statt   st_mtimet   shutilt   rmtreeR   R   (   t   freshness_thresholdt   fnt   stR   (    (    s2   lib/python2.7/site-packages/numba/tests/support.pyt   _purge_trashcan_dir  s    c         C  s'   t    t j d |  d d t  } | S(   Nt   prefixt   -t   dir(   R   t   tempfilet   mkdtempR   (   R   R   (    (    s2   lib/python2.7/site-packages/numba/tests/support.pyt   _create_trashcan_subdir   s    c         C  s   t    t |   S(   s  
    Create a temporary directory with the given *prefix* that will survive
    at least as long as this process invocation.  The temporary directory
    will be eventually deleted when it becomes stale enough.

    This is necessary because a DLL file can't be deleted while in use
    under Windows.

    An interesting side-effect is to be able to inspect the test files
    shortly after a test suite run.
    (   R   R  (   R   (    (    s2   lib/python2.7/site-packages/numba/tests/support.pyt   temp_directory%  s    c         C  s=   t  j d k r( d d l } | j   n  t |   t  j |  S(   s   
    Import and return a module of the given name.  Care is taken to
    avoid issues due to Python's internal directory caching.
    i   iN(   i   i   (   R1   R   t	   importlibt   invalidate_cachest
   __import__R2   (   t   modnameR  (    (    s2   lib/python2.7/site-packages/numba/tests/support.pyt   import_dynamic5  s
    
c         c  sO   t  t |   } t t |  t j    z t  t |   VWd t t |  |  Xd S(   s   Return a context manager used by captured_stdout/stdin/stderr
    that temporarily replaces the sys stream *stream_name* with a StringIO.N(   R   R1   R   R   t   StringIO(   t   stream_namet   orig_stdout(    (    s2   lib/python2.7/site-packages/numba/tests/support.pyt   captured_outputC  s
    c           C  s
   t  d  S(   s   Capture the output of sys.stdout:

       with captured_stdout() as stdout:
           print("hello")
       self.assertEqual(stdout.getvalue(), "hello
")
    t   stdout(   R  (    (    (    s2   lib/python2.7/site-packages/numba/tests/support.pyt   captured_stdoutN  s    c           C  s
   t  d  S(   s   Capture the output of sys.stderr:

       with captured_stderr() as stderr:
           print("hello", file=sys.stderr)
       self.assertEqual(stderr.getvalue(), "hello
")
    t   stderr(   R  (    (    (    s2   lib/python2.7/site-packages/numba/tests/support.pyt   captured_stderrW  s    c       	   c  s1   t    " }  t d t  
 |  VWd  QXWd  QXd  S(   Nt   DEBUG_CACHE(   R  R   R   (   t   out(    (    s2   lib/python2.7/site-packages/numba/tests/support.pyt   capture_cache_loga  s    t
   MemoryLeakc           B  s2   e  Z e Z d    Z d   Z d   Z d   Z RS(   c         C  s   t  j   t j   |  _ d  S(   N(   t   gct   collectR   RJ   t   _MemoryLeak__init_stats(   R   (    (    s2   lib/python2.7/site-packages/numba/tests/support.pyt   memory_leak_setupl  s    
c         C  s   |  j  r |  j   n  d  S(   N(   t   _MemoryLeak__enable_leak_checkt   assert_no_memory_leak(   R   (    (    s2   lib/python2.7/site-packages/numba/tests/support.pyt   memory_leak_teardownq  s    	c         C  sy   |  j  } t j   } | j | j } | j | j } | j | j } | j | j } |  j | |  |  j | |  d  S(   N(   R  R   RJ   RK   RL   RM   RN   RO   (   R   RF   RG   RP   RQ   RR   RS   (    (    s2   lib/python2.7/site-packages/numba/tests/support.pyR  u  s    	c         C  s   t  |  _ d  S(   N(   R   R  (   R   (    (    s2   lib/python2.7/site-packages/numba/tests/support.pyt   disable_leak_check  s    (   R'   R(   R   R  R  R  R  R  (    (    (    s2   lib/python2.7/site-packages/numba/tests/support.pyR  h  s
   			
t   MemoryLeakMixinc           B  s   e  Z d    Z d   Z RS(   c         C  s!   t  t |   j   |  j   d  S(   N(   t   superR  t   setUpR  (   R   (    (    s2   lib/python2.7/site-packages/numba/tests/support.pyR    s    c         C  s+   t  t |   j   t j   |  j   d  S(   N(   R  R  t   tearDownR  R  R  (   R   (    (    s2   lib/python2.7/site-packages/numba/tests/support.pyR     s    
(   R'   R(   R  R   (    (    (    s2   lib/python2.7/site-packages/numba/tests/support.pyR    s   	c    	      c  s  d d l  m }  d g } i  } d   } z x | D] } | j d  } |  } x! | d  D] } t | |  } qX W| d } t | |  } t |  s t d |   | | | | f <t | | |  q2 Wd VWd x0 | j   D]" \ \ } } } t | | |  q WXd S(   s   
    Forbid LLVM code generation during the execution of the context
    manager's enclosed block.

    If code generation is invoked, a RuntimeError is raised.
    i(   t   codegens"   CodeLibrary._finalize_final_modulec          _  s   t  d   d  S(   Ns   codegen forbidden by test case(   t   RuntimeError(   R!   t   kwargs(    (    s2   lib/python2.7/site-packages/numba/tests/support.pyRA     s    t   .s   %r should be callableN(   t   numba.targetsR!  t   splitR   t   callableRv   R   t   items(	   R!  t   patchpointsRF   RA   R   t   partsRH   t   attrnameR   (    (    s2   lib/python2.7/site-packages/numba/tests/support.pyt   forbid_codegen  s$    		
	c         c  s   d d l  m } t j | j  } | j   t j |   } t j   \ } } z% t j	 | |   t
 j | d  VWd | j   t j |  t j	 | |   t j |  Xd S(   st   
    Temporarily redirect *fd* to a pipe's write end and return a file object
    wrapping the pipe's read end.
    i(   t
   _helperlibt   rN(   t   numbaR-  t   ctypest   CDLLt   __file__t   _numba_flush_stdoutR   t   dupt   pipet   dup2t   iot   opent   close(   t   fdR-  t   libnumbat   saveR.  t   w(    (    s2   lib/python2.7/site-packages/numba/tests/support.pyt   redirect_fd  s    

c          C  s   t  j j   }  t |   S(   s   Redirect C stdout
    (   R1   t
   __stdout__t   filenoR>  (   R:  (    (    s2   lib/python2.7/site-packages/numba/tests/support.pyt   redirect_c_stdout  s    c   	   
   C  s6  t  j d  } | j   } t |  } t d |   | j d t d |  | g  } | j   | j   | j	   } | j	   } | r | j
   r t   t d j d d   t |  n  | r| j
   rt d t j  t d	 j d d  d t j t | d t j n  Wd
 QXi | j d 6| d 6| d 6S(   sK  Spawn a new process to run `func` with a temporary cache directory.

    The childprocess's stdout and stderr will be captured and redirected to
    the current process's stdout and stderr.

    Returns
    -------
    ret : dict
        exitcode: 0 for success. 1 for exception-raised.
        stdout: str
        stderr: str
    t   spawnt   NUMBA_CACHE_DIRt   targetR!   t   STDOUTiP   R   t   filet   STDERRNt   exitcodeR  R  (   t   mpt   get_contextt   QueueR  R   t   Processt   _remote_runnert   startR   t
   get_nowaitt   stript   printt   centerR1   R  RH  (	   R    t   cache_dir_prefixt   verboset   ctxt   qoutt	   cache_dirt   procR  R  (    (    s2   lib/python2.7/site-packages/numba/tests/support.pyt   run_in_new_process_caching  s*    


c         C  s   t    a } t   < } y |    Wn! t k
 rF t j   d } n Xd } Wd QX| j | j    Wd QX| j | j    t j |  d S(   s+   Used by `run_in_new_process_caching()`
    i   i    N(	   R  R  t	   Exceptiont	   tracebackt	   print_exct   putt   getvalueR1   t   exit(   R   RV  R  R  RH  (    (    s2   lib/python2.7/site-packages/numba/tests/support.pyRM    s    

([   R)   t
   __future__R    R   R   RV   R   R  R   R   R   t
   subprocessR1   R   R   R7  R0  t   multiprocessingRI  t   numpyR,   R/  R   R   R   R   R   R   t   numba.compilerR   R   R	   R
   R%  R   t   numba.unittest_supportt   unittest_supportt   unittestt   numba.runtimeR   t   enable_pyobj_flagst   sett   force_pyobj_flagst   no_pyobj_flagst	   nrt_flagst   make_tag_decoratort   tagRf   t
   startswithR   t   _windows_py27Rg   t   _32bitt   _reasont   skipIft   skip_parfors_unsupportedt   objectR   R+   R   R   R   R   R   R*   R   R   R   R   R   t
   gettempdirt   getuidR   R   R   R  R  R  R  R  R  R  R  R  R,  R>  RA  R'   R   RY  RM  (    (    (    s2   lib/python2.7/site-packages/numba/tests/support.pyt   <module>   s   ."				 Y	

								
#	%