def decorate(fn):
def run_test(args):
pip = pipeline.make()
argspec = tuple(from_value(arg, broaden=True) for arg in args)
result_py = fn(*args)
try:
res = pip(input=fn, argspec=argspec)
except InferenceError as ierr:
print_inference_error(ierr)
raise ierr
except ValidationError as verr:
print('Collected the following errors:')
for err in verr.errors:
n = err.node
nlbl = lbl.label(n)
print(f' {nlbl} ({type(n).__name__}) :: {n.type}')
print(f' {err.args[0]}')
raise verr
result_final = res['output'](*args)
assert _eq(result_py, result_final)
m = mark.parametrize('args', arglists)(run_test)
m.__orig__ = fn
return m
def _parametrize_side_effect_response(wrapped):
def func(websocket):
return "respdata"
def func2(websocket):
websocket.send_message("respdata")
def gen(websocket):
yield "respdata"
def gen2(websocket):
websocket.send_message("respdata")
return
yield # noqa
def bytefunc(websocket):
return b"respdata"
return mark.parametrize(
"expected_response,side_effect",
[("respdata", "respdata"), (b"respdata", b"respdata"),
("respdata", ["respdata"]), (b"respdata", [b"respdata"]),
(b"respdata", bytearray(b"respdata")), ("respdata", func),
("respdata", func2), ("respdata", gen), ("respdata", gen2),
(b"respdata", bytefunc)])(wrapped)
def decorate(fn):
def run_test(args):
pip = pipeline.make()
argspec = tuple({'value': arg} for arg in args)
pip.resources.inferrer.fill_in(argspec)
print(argspec)
for arg in argspec:
del arg['value']
result_py = fn(*args)
try:
res = pip(input=fn, argspec=argspec)
except InferenceError as ierr:
print_inference_error(ierr)
raise ierr
except ValidationError as verr:
print('Collected the following errors:')
for err in verr.errors:
n = err.node
nlbl = lbl.label(n)
print(f' {nlbl} ({type(n).__name__}) :: {n.type}')
print(f' {err.args[0]}')
raise verr
result_final = res['output'](*args)
if isinstance(result_py, numpy.ndarray):
assert (result_py == result_final).all()
else:
assert result_py == result_final
m = mark.parametrize('args', arglists)(run_test)
m.__orig__ = fn
return m
def parametrize_from(
data: List[Tuple[str, str, Any]]
) -> Callable[[Callable[..., Any]], Callable[..., Any]]:
"""Utility function to create PyTest parameters from the lists above"""
return mark.parametrize(
["definition", "expected"],
[param(definition, expected, id=key) for key, definition, expected in data],
)
def decorate(fn):
def run_test(args):
result_py = fn(*args)
res = cconv_pipeline.make()(input=fn)
check_no_free_variables(res['graph'])
result_final = res['output'](*args)
assert result_py == result_final
m = mark.parametrize('args', arglists)(run_test)
m.__orig__ = fn
return m
def decorate(fn):
def run_test(args):
result_py = fn(*args)
res = cconv_pipeline.make()(input=fn, use_llift=use_llift)
check_no_free_variables(res["graph"])
result_final = res["output"](*args)
assert result_py == result_final
m = mark.parametrize("args", arglists)(run_test)
m.__orig__ = fn
return m
def parametrize(cases: Mapping[Callable[..., Tensor],
Iterable[tuple[Iterable, Number]]]):
return mark.parametrize(
'func, args, truth',
tuple((func, args, truth) for func, vals in cases.items()
for args, truth in vals)
)(
# TODO: pytest fails with "duplicate 'func'"
# if you run multiple files that have dtyped cases
# if BaseCasesTest.test_case is not copied?!?....
partial(BaseCasesTest.test_case))
def decorate(fn):
def test(args):
if not isinstance(args, tuple):
args = (args, )
py_result = fn(*map(copy, args))
myia_fn = lang_pipeline.run(input=fn)['output']
myia_result = myia_fn(*map(copy, args))
assert py_result == myia_result
m = mark.parametrize('args', list(tests))(test)
m.__orig__ = fn
return m
def decorate(fn):
def test(args):
if not isinstance(args, tuple):
args = (args,)
_fwd_test(fn, args,
pipeline=fwd_pipeline,
optimize=optimize,
python=python)
m = mark.parametrize('args', list(tests))(test)
m.__orig__ = fn
return m
def decorate(fn):
def test(args):
if not isinstance(args, tuple):
args = (args,)
# TODO: avoid re-parsing every time
fn2 = parse(fn)
py_result = fn(*map(copy, args))
myia_result = run(fn2, tuple(map(copy, args)))
assert py_result == myia_result
m = mark.parametrize('args', list(tests))(test)
m.__orig__ = fn
return m
def decorate(fn):
def test(args):
if not isinstance(args, tuple):
args = (args,)
py_result = fn(*map(copy, args))
argspec = tuple(from_value(arg, broaden=True) for arg in args)
myia_fn = pipeline.run(input=fn, argspec=argspec)['output']
myia_result = myia_fn(*map(copy, args))
assert py_result == myia_result
m = mark.parametrize('args', list(tests))(test)
m.__orig__ = fn
return m
def decorate(fn):
def test(args):
if not isinstance(args, tuple):
args = (args, )
py_result = fn(*map(copy, args))
argspec = tuple({'value': a} for a in args)
res = debug_lin_pipeline.run(input=fn, argspec=argspec)
myia_fn = res['output']
myia_result = myia_fn(*map(copy, args))
assert py_result == myia_result
m = mark.parametrize('args', list(tests))(test)
m.__orig__ = fn
return m
def bundles(versions):
'''
Parameterize the `bundle` fixture with bundle IDs and versions to test against
Parameters
----------
versions : list of int
Versions of the bundle to test against
'''
return mark.parametrize(
'bundle',
versions,
ids=[f'{bundle_id}@{version}' for bundle_id, version in versions],
indirect=True)
def parametrize(
names: str,
vals: typing.Sequence,
ids: typing.Sequence[str]):
"""Simplify `pytest.mark.parametrize`
Arguments:
names {str} -- parameter names
vals {typing.Iterable} -- parameter values
ids {StringList} -- test IDs
"""
if not check_parametrize(vals, ids):
breakpoint()
return mark.parametrize(names, list(vals), ids=pad_to_longest(list(ids)))
def bundle_versions(fixture_name, versions):
'''
Parameterize a bundle fixture with versions of the bundle to test against
Parameters
----------
fixture_name : str
The name of the fixture to parameterize
versions : list of int
Versions of the bundle to test against
'''
return mark.parametrize(fixture_name,
versions,
ids=[f'{fixture_name}@{v}' for v in versions],
indirect=True)
def decorate(fn):
def run_test(args):
if isinstance(args, Exception):
exc = type(args)
args = args.args
else:
exc = None
pdef = pipeline
if not validate:
pdef = pdef.configure(validate=False)
pip = pdef.make()
if abstract is None:
argspec = tuple(
from_value(arg, broaden=True) for arg in args)
else:
argspec = tuple(to_abstract_test(a) for a in abstract)
if exc is not None:
try:
mfn = pip(input=fn, argspec=argspec)
mfn['output'](*args)
except exc:
pass
return
result_py = fn(*args)
try:
res = pip(input=fn, argspec=argspec)
except InferenceError as ierr:
print_inference_error(ierr)
raise ierr
except ValidationError as verr:
print('Collected the following errors:')
for err in verr.errors:
n = err.node
nlbl = lbl.label(n)
tname = type(n).__name__
print(f' {nlbl} ({tname}) :: {n.abstract}')
print(f' {err.args[0]}')
raise verr
result_final = res['output'](*args)
assert _eq(result_py, result_final)
m = mark.parametrize('args', arglists)(run_test)
m.__orig__ = fn
return m
def decorate(fn):
def test(test_data):
testfn = analysis('grad', fn).test
results = testfn(test_data)
print(results)
if not results['match']:
for row in ['python', 'myia', 'myiag']:
print(f'{row}:\t{results[row+"_result"]}')
fail('Mismatch is output values (see stdout)')
for arg, d in results["derivatives"].items():
if not d['match']:
print(f'Argument {arg}:')
print(f'\tFinite differences: {d["difference"]}')
print(f'\tGradient output: {d["exact"]}')
fail(f'Mismatch in gradients for {arg} (see stdout)')
m = mark.parametrize('test_data', list(tests))(test)
m.__orig__ = fn
return m
def decorate(fn):
def test(args):
if not isinstance(args, tuple):
args = (args, )
if python:
ref_result = fn(*map(copy, args))
argspec = tuple(from_value(arg, broaden=True) for arg in args)
res = pipeline.run(input=fn, argspec=argspec)
myia_fn = res['output']
myia_result = myia_fn(*map(copy, args))
if python:
if justeq:
assert ref_result == myia_result
else:
np.testing.assert_allclose(ref_result, myia_result)
m = mark.parametrize('args', list(tests))(test)
m.__orig__ = fn
return m
def decorate(fn):
def test(args):
nonlocal profile
if not isinstance(args, tuple):
args = (args, )
if python:
ref_result = fn(*map(copy, args))
argspec = tuple(from_value(arg, broaden=True) for arg in args)
if profile is True:
profile = Profile()
res = pipeline.run(input=fn, argspec=argspec, profile=profile)
profile.print()
myia_fn = res['output']
myia_result = myia_fn(*map(copy, args))
if python:
np.testing.assert_allclose(ref_result, myia_result)
m = mark.parametrize('args', list(tests))(test)
m.__orig__ = fn
return m
def decorate(fn):
try:
exc = None
testfn = analysis('grad2', fn).test
except Exception as e:
exc = e
def test(test_data):
if exc:
raise exc
results = testfn(test_data)
print(results)
for arg, d in results.items():
if not d['match']:
print(f'Argument {arg}:')
print(f'\tFinite differences: {d["difference"]}')
print(f'\tGradient output: {d["computed"]}')
fail(f'Mismatch in gradients for {arg} (see stdout)')
m = mark.parametrize('test_data', list(tests))(test)
m.__orig__ = fn
return m
SomeObjectType,
SomeUnionType,
SomeInterfaceType,
])
not_output_types: List[GraphQLInputType] = with_modifiers(
[SomeInputObjectType])
input_types: List[GraphQLInputType] = with_modifiers(
[GraphQLString, SomeScalarType, SomeEnumType, SomeInputObjectType])
not_input_types: List[GraphQLOutputType] = with_modifiers(
[SomeObjectType, SomeUnionType, SomeInterfaceType])
parametrize_type = partial(
mark.parametrize("type_", ids=lambda type_: type_.__class__.__name__))
def schema_with_field_type(type_):
return GraphQLSchema(
query=GraphQLObjectType(name="Query",
fields={"f": GraphQLField(type_)}),
types=[type_],
)
def describe_type_system_a_schema_must_have_object_root_types():
def accepts_a_schema_whose_query_type_is_an_object_type():
schema = build_schema("""
type Query {
test: String
"""
Unit tests.
"""
from mock import (
MagicMock,
call,
)
from pytest import mark
from threading import Thread
from pyslot import ThreadSafeSignal as Signal
with_emit_arguments = mark.parametrize('args,kwargs', [
([], {}),
([1], {}),
([], {'a': 2}),
([1], {'a': 2}),
])
@with_emit_arguments
def test_signal_emit_no_connection(args, kwargs):
signal = Signal()
signal.emit(*args, **kwargs)
@with_emit_arguments
def test_signal_emit_single_connection(args, kwargs):
callback = MagicMock()
signal = Signal()
signal.connect(callback)
@fixture(scope="session")
def fixlib():
"A fixture to guarantee that in pytest lib is finalized at the end"
if not lib.initialized:
lib.init_quda()
yield lib
if lib.initialized:
lib.end_quda()
lattice_loop = mark.parametrize(
"lattice",
[
# (2, 2, 2, 2),
# (3, 3, 3, 3),
(4, 4, 4, 4),
(8, 8, 8, 8),
],
)
device_loop = mark.parametrize(
"device",
[
True,
# False,
],
)
dtype_loop = mark.parametrize(
"dtype",
def _as_async(code: str):
return f"__import__('sys').__async_eval__({code!r}, globals(), locals())"
@fixture(autouse=True)
def _clear_modules():
for name in [*sys.modules]:
if name.startswith("pydevd") or name.startswith("async_pydevd"):
del sys.modules[name]
params_mark = mark.parametrize(
"code,result",
[
("foo()", ) * 2,
(_as_async("await foo()"), ) * 2,
("await foo()", _as_async("await foo()")),
],
)
@params_mark
def test_evaluate_expression(mocker, code, result):
mock_eval: MagicMock = mocker.patch(
"_pydevd_bundle.pydevd_vars.evaluate_expression")
mock_find_frame: MagicMock = mocker.patch(
"_pydevd_bundle.pydevd_vars.find_frame")
from async_pydevd import pydevd_patch # noqa # isort:skip
from _pydevd_bundle.pydevd_vars import evaluate_expression # isort:skip
def pytest_parametrize(*args, **kwargs):
from pytest import mark
return mark.parametrize(*pytest_variants(*args, **kwargs))
def parametrise_dictionaries(db):
return mark.parametrize("dictionary", [
get_mem_dictionary(),
get_db_dictionary(db),
],
ids=lambda x: type(x).__name__)
import lenskit.util.test as lktu
from lenskit.algorithms import Recommender
from lenskit.util import Stopwatch
from hypothesis import given
from hypothesis.strategies import randoms
_log = logging.getLogger(__name__)
simple_df = pd.DataFrame({
'item': [1, 1, 2, 3],
'user': [10, 12, 10, 13],
'rating': [4.0, 3.0, 5.0, 2.0]
})
methods = mark.parametrize('m', ['lu', 'cg'])
@methods
def test_als_basic_build(m):
algo = als.ImplicitMF(20,
iterations=10,
progress=util.no_progress,
method=m)
algo.fit(simple_df)
assert set(algo.user_index_) == set([10, 12, 13])
assert set(algo.item_index_) == set([1, 2, 3])
assert algo.user_features_.shape == (3, 20)
assert algo.item_features_.shape == (3, 20)
def parametrise_hashers(db):
return mark.parametrize("hasher", [
MemWordHasher(),
DBWordHasher(db, 'test'),
],
ids=lambda x: type(x).__name__)
import lenskit.util.test as lktu
from lenskit import sharing as lks
from lenskit.algorithms import Recommender
from lenskit.algorithms.basic import Popular
from lenskit.algorithms.als import BiasedMF
from lenskit.algorithms.item_knn import ItemItem
from pytest import mark
stores = [lks.FileModelStore]
if pickle.HIGHEST_PROTOCOL >= 5:
# we have Python 3.8
stores.append(lks.SHMModelStore)
store_param = mark.parametrize('store_cls', stores)
def test_sharing_mode():
"Ensure sharing mode decorator turns on sharing"
assert not lks.in_share_context()
with lks.sharing_mode():
assert lks.in_share_context()
assert not lks.in_share_context()
@store_param
def test_store_init(store_cls):
"Test that a store initializes and shuts down."
def expectJobDone(self):
self.__nrFinishedJobs += 1
def expectScheduleDone(self):
self.__isDone = True
@fixture
def sim(request, databases):
preparedTime = getattr(request, 'param', None)
return Simulator(databases, preparedTime)
time2007 = mark.parametrize('sim',
[int(time.mktime((2007, 1, 1, 0, 0, 0, 0, 1, 0)))],
indirect=True)
"""Start Monday 2007-01-01 at midnight."""
def testScheduleNonExistingOnce(sim):
"""Test one-shot schedule with a non-existing config."""
sim.prepare(-120, ScheduleRepeat.ONCE, missingConfig=True)
sim.expectScheduleDone()
sim.wait(60)
def testScheduleNonExistingRepeat(sim):
"""Test daily schedule with a non-existing config."""
import os
from hamcrest import *
from mock import patch
from pytest import mark
from pizzapy.address import Address
from pizzapy.urls import Urls, COUNTRY_USA
fixture_path = os.path.join('tests', 'fixtures', 'stores.json')
with open(fixture_path) as fp:
stores_fixture = json.load(fp)
address_params = mark.parametrize(
argnames=('street', 'city', 'region', 'zip'),
argvalues=[('700 Pennsylvania Avenue NW', 'Washington', 'DC', '20408'),
('700 Pennsylvania Avenue NW ', ' Washington ', ' DC ',
' 20408 '),
('700 Pennsylvania Avenue NW', 'Washington', 'DC', 20408)])
def mocked_request_json(url, **kwargs):
assert_that(url, equal_to(Urls(COUNTRY_USA).find_url()))
assert_that(
kwargs,
has_entries(line1='700 Pennsylvania Avenue NW',
line2='Washington, DC, 20408',
type='Delivery'))
return stores_fixture
def backends(*backends):
return mark.parametrize(('backend',), [(b(),) for b in backends])
