class TestThreadingLayerSelection(ThreadLayerTestHelper): """ Checks that numba.threading_layer() reports correctly. """ _DEBUG = False backends = { 'tbb': skip_no_tbb, 'omp': skip_no_omp, 'workqueue': unittest.skipIf(False, '') } @classmethod def _inject(cls, backend, backend_guard): def test_template(self): body = """if 1: X = np.arange(1000000.) Y = np.arange(1000000.) Z = busy_func(X, Y) assert numba.threading_layer() == '%s' """ runme = self.template % (body % backend) cmdline = [sys.executable, '-c', runme] env = os.environ.copy() env['NUMBA_THREADING_LAYER'] = str(backend) out, err = self.run_cmd(cmdline, env=env) if self._DEBUG: print(out, err) injected_test = "test_threading_layer_selector_%s" % backend setattr(cls, injected_test, tag("important")(backend_guard(test_template))) @classmethod def generate(cls): for backend, backend_guard in cls.backends.items(): cls._inject(backend, backend_guard)
try: import setuptools except ImportError: setuptools = None import llvmlite.binding as ll from numba import unittest_support as unittest from numba.pycc import main from numba.pycc.decorators import clear_export_registry from numba.pycc.platform import find_shared_ending, find_pyext_ending from numba.pycc.platform import _external_compiler_ok # if suitable compilers are not present then skip. _skip_reason = 'AOT compatible compilers missing' _skip_missing_compilers = unittest.skipIf(not _external_compiler_ok, _skip_reason) _skip_reason = 'windows only' _windows_only = unittest.skipIf(not sys.platform.startswith('win'), _skip_reason) from .matmul_usecase import has_blas from .support import TestCase, tag, import_dynamic, temp_directory base_path = os.path.dirname(os.path.abspath(__file__)) def unset_macosx_deployment_target(): """Unset MACOSX_DEPLOYMENT_TARGET because we are not building portable libraries """
from numba import njit, gdb, gdb_init, gdb_breakpoint, prange, errors from numba import jit from numba import unittest_support as unittest from numba.targets.gdb_hook import _confirm_gdb from .support import (TestCase, captured_stdout, tag) from .test_parfors import skip_unsupported as parfors_skip_unsupported _platform = sys.platform _unix_like = (_platform.startswith('linux') or _platform.startswith('darwin') or ('bsd' in _platform)) unix_only = unittest.skipUnless(_unix_like, "unix-like OS is required") not_unix = unittest.skipIf(_unix_like, "non unix-like OS is required") _arch_name = platform.machine() _is_arm = _arch_name in {'aarch64', 'armv7l'} not_arm = unittest.skipIf(_is_arm, "testing disabled on ARM") _gdb_cond = os.environ.get('GDB_TEST', None) == '1' needs_gdb_harness = unittest.skipUnless(_gdb_cond, "needs gdb harness") # check if gdb is present and working try: _confirm_gdb() _HAVE_GDB = True except Exception: _HAVE_GDB = False
import sys import numpy as np from numba.compiler import compile_isolated, Flags from numba import jit, types, utils, njit, errors import numba.unittest_support as unittest from numba import testing from numba.six import PY2 from .support import TestCase, MemoryLeakMixin, tag from numba.targets.quicksort import make_py_quicksort, make_jit_quicksort from numba.targets.mergesort import make_jit_mergesort from .timsort import make_py_timsort, make_jit_timsort, MergeRun skip_py_27 = unittest.skipIf(PY2, "Not supported on Python 2") def make_temp_list(keys, n): return [keys[0]] * n def make_temp_array(keys, n): return np.empty(n, keys.dtype) py_list_timsort = make_py_timsort(make_temp_list) py_array_timsort = make_py_timsort(make_temp_array) jit_list_timsort = make_jit_timsort(make_temp_list)
import setuptools except ImportError: setuptools = None import llvmlite.binding as ll from numba import unittest_support as unittest from numba import utils from numba.pycc import main from numba.pycc.decorators import clear_export_registry from numba.pycc.platform import find_shared_ending, find_pyext_ending from numba.pycc.platform import _external_compiler_ok # if suitable compilers are not present then skip. _skip_reason = 'AOT compatible compilers missing' _skip_missing_compilers = unittest.skipIf(not _external_compiler_ok, _skip_reason) _skip_reason = 'windows only' _windows_only = unittest.skipIf(not sys.platform.startswith('win'), _skip_reason) from .support import TestCase, tag, import_dynamic, temp_directory, has_blas base_path = os.path.dirname(os.path.abspath(__file__)) def unset_macosx_deployment_target(): """Unset MACOSX_DEPLOYMENT_TARGET because we are not building portable libraries """ if 'MACOSX_DEPLOYMENT_TARGET' in os.environ: del os.environ['MACOSX_DEPLOYMENT_TARGET']
from numba import types, typing, utils from numba.compiler import compile_extra, compile_isolated, Flags, DEFAULT_FLAGS from numba.lowering import LoweringError from numba.targets import cpu from numba.typeinfer import TypingError import numba.unittest_support as unittest enable_pyobj_flags = Flags() enable_pyobj_flags.set("enable_pyobject") force_pyobj_flags = Flags() force_pyobj_flags.set("force_pyobject") no_pyobj_flags = Flags() skip_on_numpy_16 = unittest.skipIf(np.__version__.startswith("1.6."), "test requires Numpy 1.7 or later") class CompilationCache(object): """ A cache of compilation results for various signatures and flags. This can make tests significantly faster (or less slow). """ def __init__(self): self.typingctx = typing.Context() self.targetctx = cpu.CPUContext(self.typingctx) self.cr_cache = {} def compile(self, func, args, return_type=None, flags=DEFAULT_FLAGS): """ Compile the function or retrieve an already compiled result
from numba.targets import cpu import numba.unittest_support as unittest from numba.runtime import rtsys enable_pyobj_flags = Flags() enable_pyobj_flags.set("enable_pyobject") force_pyobj_flags = Flags() force_pyobj_flags.set("force_pyobject") no_pyobj_flags = Flags() is_on_numpy_16 = numpy_support.version == (1, 6) skip_on_numpy_16 = unittest.skipIf(is_on_numpy_16, "test requires Numpy 1.7 or later") class CompilationCache(object): """ A cache of compilation results for various signatures and flags. This can make tests significantly faster (or less slow). """ def __init__(self): self.typingctx = typing.Context() self.targetctx = cpu.CPUContext(self.typingctx) self.cr_cache = {} def compile(self, func, args, return_type=None, flags=DEFAULT_FLAGS): """
class TestThreadingLayerSelection(ThreadLayerTestHelper): """ Checks that numba.threading_layer() reports correctly. """ _DEBUG = False backends = {'tbb': skip_no_tbb, 'omp': skip_no_omp, 'workqueue': unittest.skipIf(False, '')} @classmethod def _inject(cls, backend, backend_guard): def test_template(self): body = """if 1: X = np.arange(1000000.) Y = np.arange(1000000.) Z = busy_func(X, Y) assert numba.threading_layer() == '%s' """ runme = self.template % (body % backend) cmdline = [sys.executable, '-c', runme] env = os.environ.copy() env['NUMBA_THREADING_LAYER'] = str(backend) out, err = self.run_cmd(cmdline, env=env) if self._DEBUG: print(out, err) injected_test = "test_threading_layer_selector_%s" % backend setattr(cls, injected_test, tag("important")(backend_guard(test_template))) @classmethod def generate(cls): for backend, backend_guard in cls.backends.items(): cls._inject(backend, backend_guard) @skip_no_tbb @skip_unless_py3 def test_single_thread_tbb(self): """ Tests that TBB works well with single thread https://github.com/numba/numba/issues/3440 """ runme = """if 1: from numba import njit, prange, threading_layer @njit(parallel=True) def foo(n): acc = 0 for i in prange(n): acc += i return acc foo(100) print(threading_layer()) """ cmdline = [sys.executable, '-c', runme] env = os.environ.copy() env['NUMBA_THREADING_LAYER'] = "tbb" env['NUMBA_NUM_THREADS'] = "1" out, err = self.run_cmd(cmdline, env=env) if self._DEBUG: print(out, err) assert out.strip() == "tbb"
def truediv(a, b): return a / b def floordiv(a, b): return a // b def remainder(a, b): return a % b def power(a, b): return a ** b # See https://github.com/numpy/numpy/pull/3691 skipIfFPStatusBug = unittest.skipIf( sys.platform == 'win32' and np_version < (1, 8) and sys.maxsize < 2 ** 32, "test disabled because of FPU state handling issue on Numpy < 1.8") class TestExceptions(TestCase): """ Test raising exceptions inside ufuncs. """ def check_ufunc_raise(self, **vectorize_args): f = vectorize(['float64(float64)'], **vectorize_args)(sqrt) arr = np.array([1, 4, -2, 9, -1, 16], dtype=np.float64) out = np.zeros_like(arr) with self.assertRaises(ValueError) as cm: f(arr, out) self.assertIn('Value must be positive', str(cm.exception))
from numba.utils import PYVERSION from .support import TestCase, enable_pyobj_flags def build_set_usecase(*args): ns = {} src = """if 1: def build_set(): return {%s} """ % ', '.join(repr(arg) for arg in args) code = compile(src, '<>', 'exec') eval(code, ns) return ns['build_set'] needs_set_literals = unittest.skipIf(PYVERSION < (2, 7), "set literals unavailable before Python 2.7") class SetTestCase(TestCase): @needs_set_literals def test_build_set(self, flags=enable_pyobj_flags): pyfunc = build_set_usecase(1, 2, 3, 2) self.run_nullary_func(pyfunc, flags=flags) @needs_set_literals def test_build_heterogenous_set(self, flags=enable_pyobj_flags): pyfunc = build_set_usecase(1, 2.0, 3j, 2) self.run_nullary_func(pyfunc, flags=flags) # Check that items are inserted in the right order (here the # result will be {2}, not {2.0})
return pow_usecase # On 64-bit Windows, MSVC 2008 (Python 2.7) and Numpy 1.9, there's a # heisenbug that seems to manifest as wrong values returned by the CRT's # fmodf() function (which is called by LLVM's lowering of the `frem` # instruction). # Perhaps Numpy messing with some internal FP state that confuses the CRT? # Regardless, the only sane thing to do seems to be to skip the tests... _windows_floordiv_heisenbug = (sys.platform == 'win32' and numpy_support.version[:2] == (1, 9) and MACHINE_BITS == 64) _avoid_windows_floordiv_heisenbug = unittest.skipIf( _windows_floordiv_heisenbug, "avoid Windows + Numpy floordiv heisenbug - see PR #2057") class LiteralOperatorImpl(object): @staticmethod def add_usecase(x, y): return x + y @staticmethod def iadd_usecase(x, y): x += y return x @staticmethod def sub_usecase(x, y):
force_pyobj_flags = Flags() force_pyobj_flags.set("force_pyobject") no_pyobj_flags = Flags() nrt_flags = Flags() nrt_flags.set("nrt") tag = testing.make_tag_decorator(['important', 'long_running']) _windows_py27 = (sys.platform.startswith('win32') and sys.version_info[:2] == (2, 7)) _32bit = sys.maxsize <= 2**32 _reason = 'parfors not supported' skip_parfors_unsupported = unittest.skipIf(_32bit or _windows_py27, _reason) skip_py38_or_later = unittest.skipIf(utils.PYVERSION >= (3, 8), "unsupported on py3.8 or later") class CompilationCache(object): """ A cache of compilation results for various signatures and flags. This can make tests significantly faster (or less slow). """ def __init__(self): self.typingctx = typing.Context() self.targetctx = cpu.CPUContext(self.typingctx) self.cr_cache = {} def compile(self, func, args, return_type=None, flags=DEFAULT_FLAGS):
from numba import unittest_support as unittest from numba import (njit, typeof, types, typing, typeof, ir, utils, bytecode, jitclass, prange) from .support import TestCase, tag from numba.array_analysis import EquivSet, ArrayAnalysis from numba.compiler import Pipeline, Flags, _PipelineManager from numba.targets import cpu, registry from numba.numpy_support import version as numpy_version from numba.ir_utils import remove_dead # for parallel tests, marking that Windows with Python 2.7 is not supported _windows_py27 = (sys.platform.startswith('win32') and sys.version_info[:2] == (2, 7)) _32bit = sys.maxsize <= 2 ** 32 _reason = 'parfors not supported' skip_unsupported = unittest.skipIf(_32bit or _windows_py27, _reason) # test class for #3700 @jitclass([('L', types.int32), ('T', types.int32)]) class ExampleClass3700(object): def __init__(self, n): self.L = n self.T = n + 1 class TestEquivSet(TestCase): """ Test array_analysis.EquivSet. """
enable_pyobj_flags = Flags() enable_pyobj_flags.set("enable_pyobject") force_pyobj_flags = Flags() force_pyobj_flags.set("force_pyobject") no_pyobj_flags = Flags() nrt_flags = Flags() nrt_flags.set("nrt") tag = testing.make_tag_decorator(['important', 'long_running']) _32bit = sys.maxsize <= 2 ** 32 skip_parfors_unsupported = unittest.skipIf(_32bit, 'parfors not supported') skip_py38_or_later = unittest.skipIf( utils.PYVERSION >= (3, 8), "unsupported on py3.8 or later" ) skip_tryexcept_unsupported = unittest.skipIf( utils.PYVERSION < (3, 7), "try-except unsupported on py3.6 or earlier" ) skip_tryexcept_supported = unittest.skipIf( utils.PYVERSION >= (3, 7), "try-except supported on py3.7 or later" ) _msg = "SciPy needed for test" skip_unless_scipy = unittest.skipIf(scipy is None, _msg)
force_pyobj_flags = Flags() force_pyobj_flags.set("force_pyobject") no_pyobj_flags = Flags() nrt_flags = Flags() nrt_flags.set("nrt") tag = testing.make_tag_decorator(['important', 'long_running']) _windows_py27 = (sys.platform.startswith('win32') and sys.version_info[:2] == (2, 7)) _32bit = sys.maxsize <= 2**32 _reason = 'parfors not supported' skip_parfors_unsupported = unittest.skipIf(_32bit or _windows_py27, _reason) skip_py38_or_later = unittest.skipIf(utils.PYVERSION >= (3, 8), "unsupported on py3.8 or later") skip_tryexcept_unsupported = unittest.skipIf( utils.PYVERSION < (3, 7), "try-except unsupported on py3.6 or earlier") skip_tryexcept_supported = unittest.skipIf( utils.PYVERSION >= (3, 7), "try-except supported on py3.7 or later") _msg = "SciPy needed for test" skip_unless_scipy = unittest.skipIf(scipy is None, _msg) class CompilationCache(object): """ A cache of compilation results for various signatures and flags. This can make tests significantly faster (or less slow).
def skip_on_cudasim(reason): return unittest.skipIf(config.ENABLE_CUDASIM, reason)
from numba import njit, gdb, gdb_init, gdb_breakpoint, prange, errors from numba import jit from numba import unittest_support as unittest from numba.targets.gdb_hook import _confirm_gdb from .support import (TestCase, captured_stdout, tag) from .test_parfors import skip_unsupported as parfors_skip_unsupported _platform = sys.platform _unix_like = (_platform.startswith('linux') or _platform.startswith('darwin') or ('bsd' in _platform)) unix_only = unittest.skipUnless(_unix_like, "unix-like OS is required") not_unix = unittest.skipIf(_unix_like, "non unix-like OS is required") _gdb_cond = os.environ.get('GDB_TEST', None) == '1' needs_gdb_harness = unittest.skipUnless(_gdb_cond, "needs gdb harness") # check if gdb is present and working try: _confirm_gdb() _HAVE_GDB = True except Exception: _HAVE_GDB = False _msg = "functioning gdb with correct ptrace permissions is required" needs_gdb = unittest.skipUnless(_HAVE_GDB, _msg) long_running = tag('long_running')
try: import setuptools except ImportError: setuptools = None import llvmlite.binding as ll from numba import unittest_support as unittest from numba.pycc import main from numba.pycc.decorators import clear_export_registry from numba.pycc.platform import find_shared_ending, find_pyext_ending from numba.pycc.platform import _external_compiler_ok # if suitable compilers are not present then skip. _skip_reason = 'AOT compatible compilers missing' _skip_missing_compilers = unittest.skipIf(not _external_compiler_ok, _skip_reason) from .matmul_usecase import has_blas from .support import TestCase, tag, import_dynamic, temp_directory base_path = os.path.dirname(os.path.abspath(__file__)) def unset_macosx_deployment_target(): """Unset MACOSX_DEPLOYMENT_TARGET because we are not building portable libraries """ if 'MACOSX_DEPLOYMENT_TARGET' in os.environ: del os.environ['MACOSX_DEPLOYMENT_TARGET']
return pow_usecase # On 64-bit Windows, MSVC 2008 (Python 2.7) and Numpy 1.9, there's a # heisenbug that seems to manifest as wrong values returned by the CRT's # fmodf() function (which is called by LLVM's lowering of the `frem` # instruction). # Perhaps Numpy messing with some internal FP state that confuses the CRT? # Regardless, the only sane thing to do seems to be to skip the tests... _windows_floordiv_heisenbug = ( sys.platform == 'win32' and numpy_support.version[:2] == (1, 9) and MACHINE_BITS == 64) _avoid_windows_floordiv_heisenbug = unittest.skipIf( _windows_floordiv_heisenbug, "avoid Windows + Numpy floordiv heisenbug - see PR #2057") class LiteralOperatorImpl(object): @staticmethod def add_usecase(x, y): return x + y @staticmethod def iadd_usecase(x, y): x += y return x @staticmethod
nrt, ) from numba.extending import intrinsic, include_path from numba.typing import signature from numba.targets.imputils import impl_ret_untracked from llvmlite import ir import llvmlite.binding as llvm from numba import cffi_support from numba.unsafe.nrt import NRT_get_api from .support import MemoryLeakMixin, TestCase, temp_directory, import_dynamic enable_nrt_flags = Flags() enable_nrt_flags.set("nrt") linux_only = unittest.skipIf(not sys.platform.startswith('linux'), 'linux only test') x86_only = unittest.skipIf(platform.machine() not in ('i386', 'x86_64'), 'x86 only test') class Dummy(object): alive = 0 def __init__(self): type(self).alive += 1 def __del__(self): type(self).alive -= 1 class TestNrtMemInfoNotInitialized(unittest.TestCase):
from numba.lowering import LoweringError from numba.targets import cpu from numba.typeinfer import TypingError import numba.unittest_support as unittest enable_pyobj_flags = Flags() enable_pyobj_flags.set("enable_pyobject") force_pyobj_flags = Flags() force_pyobj_flags.set("force_pyobject") no_pyobj_flags = Flags() skip_on_numpy_16 = unittest.skipIf(np.__version__.startswith("1.6."), "test requires Numpy 1.7 or later") class CompilationCache(object): """ A cache of compilation results for various signatures and flags. This can make tests significantly faster (or less slow). """ def __init__(self): self.typingctx = typing.Context() self.targetctx = cpu.CPUContext(self.typingctx) self.cr_cache = {} def compile(self, func, args, return_type=None, flags=DEFAULT_FLAGS): """
from numba.compiler import compile_extra, compile_isolated, Flags, DEFAULT_FLAGS from numba.targets import cpu import numba.unittest_support as unittest enable_pyobj_flags = Flags() enable_pyobj_flags.set("enable_pyobject") force_pyobj_flags = Flags() force_pyobj_flags.set("force_pyobject") no_pyobj_flags = Flags() is_on_numpy_16 = np.__version__.startswith("1.6.") skip_on_numpy_16 = unittest.skipIf(is_on_numpy_16, "test requires Numpy 1.7 or later") class CompilationCache(object): """ A cache of compilation results for various signatures and flags. This can make tests significantly faster (or less slow). """ def __init__(self): self.typingctx = typing.Context() self.targetctx = cpu.CPUContext(self.typingctx) self.cr_cache = {} def compile(self, func, args, return_type=None, flags=DEFAULT_FLAGS): """
from __future__ import print_function, unicode_literals import platform import numpy as np import numba.unittest_support as unittest from numba import jit, utils, from_dtype, types from numba.typed import Dict from numba.tests.support import TestCase skip_py2 = unittest.skipIf(not utils.IS_PY3, "not supported in Python 2") require_py37 = unittest.skipIf(utils.PYVERSION < (3, 7), "requires Python 3.7+") def getitem(x, i): return x[i] def getitem2(x, i, j): return x[i][j] def setitem(x, i, v): x[i] = v return x def setitem2(x, i, y, j): x[i] = y[j] return x
def reflect_dual(sa, sb): sa.add(sb.pop()) return sa is sb def unique_usecase(src): seen = set() res = [] for v in src: if v not in seen: seen.add(v) res.append(v) return res needs_set_literals = unittest.skipIf(sys.version_info < (2, 7), "set literals unavailable before Python 2.7") class BaseTest(MemoryLeakMixin, TestCase): def setUp(self): super(BaseTest, self).setUp() self.rnd = random.Random(42) def _range(self, stop): return np.arange(int(stop)) def _random_choice(self, seq, n): """ Choose *n* possibly duplicate items from sequence. """
def reflect_dual(sa, sb): sa.add(sb.pop()) return sa is sb def unique_usecase(src): seen = set() res = [] for v in src: if v not in seen: seen.add(v) res.append(v) return res needs_set_literals = unittest.skipIf( sys.version_info < (2, 7), "set literals unavailable before Python 2.7") class BaseTest(MemoryLeakMixin, TestCase): def setUp(self): super(BaseTest, self).setUp() self.rnd = random.Random(42) def _range(self, stop): return np.arange(int(stop)) def _random_choice(self, seq, n): """ Choose *n* possibly duplicate items from sequence. """ l = [self.rnd.choice(list(seq)) for i in range(n)]
def floordiv(a, b): return a // b def remainder(a, b): return a % b def power(a, b): return a**b # See https://github.com/numpy/numpy/pull/3691 skipIfFPStatusBug = unittest.skipIf( sys.platform == 'win32' and np_version < (1, 8) and sys.maxsize < 2**32, "test disabled because of FPU state handling issue on Numpy < 1.8") class TestExceptions(TestCase): """ Test raising exceptions inside ufuncs. """ def check_ufunc_raise(self, **vectorize_args): f = vectorize(['float64(float64)'], **vectorize_args)(sqrt) arr = np.array([1, 4, -2, 9, -1, 16], dtype=np.float64) out = np.zeros_like(arr) with self.assertRaises(ValueError) as cm: f(arr, out) self.assertIn('Value must be positive', str(cm.exception)) # All values were computed except for the ones giving an error
from numba.interpreter import Interpreter from numba import typing, errors from numba.targets.registry import cpu_target from numba.targets import cpu from numba.compiler import compile_ir, DEFAULT_FLAGS from numba import njit, typeof, objmode from .support import MemoryLeak, TestCase, captured_stdout try: import scipy except ImportError: scipy = None _msg = "SciPy needed for test" skip_unless_scipy = unittest.skipIf(scipy is None, _msg) def get_func_ir(func): func_id = FunctionIdentity.from_function(func) bc = ByteCode(func_id=func_id) interp = Interpreter(func_id) func_ir = interp.interpret(bc) return func_ir def lift1(): print("A") with bypass_context: print("B") b()
class TestSpecificBackend(TestParallelBackendBase): """ This is quite contrived, for each test in the TestParallelBackend tests it generates a test that will run the TestParallelBackend test in a new python process with an environment modified to ensure a specific threadsafe backend is used. This is with view of testing the backends independently and in an isolated manner such that if they hang/crash/have issues, it doesn't kill the test suite. """ _DEBUG = False backends = { 'tbb': skip_no_tbb, 'omp': skip_no_omp, 'workqueue': unittest.skipIf(False, '') } def run_cmd(self, cmdline, env): popen = subprocess.Popen(cmdline, stdout=subprocess.PIPE, stderr=subprocess.PIPE, env=env) # finish in 5 minutes or kill it timeout = threading.Timer(5 * 60., popen.kill) try: timeout.start() out, err = popen.communicate() if popen.returncode != 0: raise AssertionError( "process failed with code %s: stderr follows\n%s\n" % (popen.returncode, err.decode())) return out.decode(), err.decode() finally: timeout.cancel() return None, None def run_test_in_separate_process(self, test, threading_layer): env_copy = os.environ.copy() env_copy['NUMBA_THREADING_LAYER'] = str(threading_layer) cmdline = [sys.executable, "-m", "numba.runtests", test] return self.run_cmd(cmdline, env_copy) @classmethod def _inject(cls, p, name, backend, backend_guard): themod = cls.__module__ thecls = TestParallelBackend.__name__ methname = "test_" + p + '_' + name injected_method = '%s.%s.%s' % (themod, thecls, methname) def test_template(self): o, e = self.run_test_in_separate_process(injected_method, backend) if self._DEBUG: print('stdout:\n "%s"\n stderr:\n "%s"' % (o, e)) self.assertIn('OK', e) self.assertTrue('FAIL' not in e) self.assertTrue('ERROR' not in e) injected_test = "test_%s_%s_%s" % (p, name, backend) # Mark as important for appveyor setattr(cls, injected_test, tag("important")(backend_guard(test_template))) @classmethod def generate(cls): for backend, backend_guard in cls.backends.items(): for p in cls.parallelism: for name in cls.runners.keys(): # handle known problem cases... # GNU OpenMP is not fork safe if (p in ('multiprocessing_fork', 'random') and backend == 'omp' and sys.platform.startswith('linux')): continue # workqueue is not thread safe if (p in ('threading', 'random') and backend == 'workqueue'): continue cls._inject(p, name, backend, backend_guard)
from numba import unittest_support as unittest from numba import njit, typeof, types, typing, typeof, ir, utils, bytecode from .support import TestCase, tag from numba.array_analysis import EquivSet, ArrayAnalysis from numba.compiler import Pipeline, Flags, _PipelineManager from numba.targets import cpu, registry from numba.numpy_support import version as numpy_version from numba.ir_utils import remove_dead # for parallel tests, marking that Windows with Python 2.7 is not supported _windows_py27 = (sys.platform.startswith('win32') and sys.version_info[:2] == (2, 7)) _32bit = sys.maxsize <= 2 ** 32 _reason = 'parfors not supported' skip_unsupported = unittest.skipIf(_32bit or _windows_py27, _reason) class TestEquivSet(TestCase): """ Test array_analysis.EquivSet. """ @tag('important') def test_insert_equiv(self): s1 = EquivSet() s1.insert_equiv('a', 'b') self.assertTrue(s1.is_equiv('a', 'b')) self.assertTrue(s1.is_equiv('b', 'a')) s1.insert_equiv('c', 'd') self.assertTrue(s1.is_equiv('c', 'd')) self.assertFalse(s1.is_equiv('c', 'a'))
from numba import njit, targets, typing from numba.compiler import compile_isolated, Flags, types from numba.runtime import rtsys from numba.runtime import nrtopt from numba.extending import intrinsic from numba.typing import signature from numba.targets.imputils import impl_ret_untracked from llvmlite import ir import llvmlite.binding as llvm from .support import MemoryLeakMixin, TestCase enable_nrt_flags = Flags() enable_nrt_flags.set("nrt") linux_only = unittest.skipIf(not sys.platform.startswith('linux'), 'linux only test') x86_only = unittest.skipIf(platform.machine() not in ('i386', 'x86_64'), 'x86 only test') class Dummy(object): alive = 0 def __init__(self): type(self).alive += 1 def __del__(self): type(self).alive -= 1 class TestNrtMemInfoNotInitialized(unittest.TestCase):