def for_dtypes_combination(types, names=['dtype'], full=None):
if full is None:
full = int(os.environ.get('CUPY_TEST_FULL_COMBINATION', '0')) != 0
if full:
combination = parameterized.product({name: types for name in names})
else:
ts = []
for _ in range(len(names)):
# Make shffuled list of types for each name
t = list(types)
random.shuffle(t)
ts.append(t)
combination = [dict(zip(names, typs)) for typs in zip(*ts)]
def decorator(impl):
@functools.wraps(impl)
def test_func(self, *args, **kw):
for dtypes in combination:
kw_copy = kw.copy()
kw_copy.update(dtypes)
try:
impl(self, *args, **kw_copy)
except Exception:
print(dtypes)
raise
return test_func
return decorator
def for_dtypes_combination(types, names=['dtype'], full=None):
if full is None:
full = int(os.environ.get('CUPY_TEST_FULL_COMBINATION', '0')) != 0
if full:
combination = parameterized.product({name: types for name in names})
else:
ts = []
for _ in range(len(names)):
# Make shffuled list of types for each name
t = list(types)
random.shuffle(t)
ts.append(t)
combination = [dict(zip(names, typs)) for typs in zip(*ts)]
def decorator(impl):
@functools.wraps(impl)
def test_func(self, *args, **kw):
for dtypes in combination:
kw_copy = kw.copy()
kw_copy.update(dtypes)
try:
impl(self, *args, **kw_copy)
except Exception:
print(dtypes)
raise
return test_func
return decorator
def for_dtypes_combination(types, names=('dtype',), full=None):
"""Decorator that checks the fixture with a product set of dtypes.
Args:
types(list of dtypes): dtypes to be tested.
names(list of str): Argument names to which dtypes are passed.
full(bool): If ``True``, then all combinations
of dtypes will be tested.
Otherwise, the subset of combinations will be tested
(see the description below).
Decorator adds the keyword arguments specified by ``names``
to the test fixture. Then, it runs the fixtures in parallel
with passing (possibly a subset of) the product set of dtypes.
The range of dtypes is specified by ``types``.
The combination of dtypes to be tested changes depending
on the option ``full``. If ``full`` is ``True``,
all combinations of ``types`` are tested.
Sometimes, such an exhaustive test can be costly.
So, if ``full`` is ``False``, only a subset of possible combinations
is randomly sampled. If ``full`` is ``None``, the behavior is
determined by an environment variable ``CUPY_TEST_FULL_COMBINATION``.
If the value is set to ``'1'``, it behaves as if ``full=True``, and
otherwise ``full=False``.
"""
types = list(types)
if len(types) == 1:
name, = names
return for_dtypes(types, name)
if full is None:
full = int(os.environ.get('CUPY_TEST_FULL_COMBINATION', '0')) != 0
if full:
combination = parameterized.product({name: types for name in names})
else:
ts = []
for _ in range(len(names)):
# Make shuffled list of types for each name
shuffled_types = types[:]
random.shuffle(shuffled_types)
ts.append(types + shuffled_types)
combination = [tuple(zip(names, typs)) for typs in zip(*ts)]
# Remove duplicate entries
combination = [dict(assoc_list) for assoc_list in set(combination)]
def decorator(impl):
@functools.wraps(impl)
def test_func(self, *args, **kw):
for dtypes in combination:
kw_copy = kw.copy()
kw_copy.update(dtypes)
try:
impl(self, *args, **kw_copy)
except Exception:
print(dtypes)
raise
return test_func
return decorator
def for_dtypes_combination(types, names=('dtype',), full=None):
"""Decorator that checks the fixture with a product set of dtypes.
Args:
types(list of dtypes): dtypes to be tested.
names(list of str): Argument names to which dtypes are passed.
full(bool): If ``True``, then all combinations
of dtypes will be tested.
Otherwise, the subset of combinations will be tested
(see the description below).
Decorator adds the keyword arguments specified by ``names``
to the test fixture. Then, it runs the fixtures in parallel
with passing (possibly a subset of) the product set of dtypes.
The range of dtypes is specified by ``types``.
The combination of dtypes to be tested changes depending
on the option ``full``. If ``full`` is ``True``,
all combinations of ``types`` are tested.
Sometimes, such an exhaustive test can be costly.
So, if ``full`` is ``False``, only the subset of possible
combinations is tested. Specifically, at first,
the shuffled lists of ``types`` are made for each argument
name in ``names``.
Let the lists be ``D1``, ``D2``, ..., ``Dn``
where :math:`n` is the number of arguments.
Then, the combinations to be tested will be ``zip(D1, ..., Dn)``.
If ``full`` is ``None``, the behavior is switched
by setting the environment variable ``CUPY_TEST_FULL_COMBINATION=1``.
For example, let ``types`` be ``[float16, float32, float64]``
and ``names`` be ``['a_type', 'b_type']``. If ``full`` is ``True``,
then the decorated test fixture is executed with all
:math:`2^3` patterns. On the other hand, if ``full`` is ``False``,
shuffled lists are made for ``a_type`` and ``b_type``.
Suppose the lists are ``(16, 64, 32)`` for ``a_type`` and
``(32, 64, 16)`` for ``b_type`` (prefixes are removed for short).
Then the combinations of ``(a_type, b_type)`` to be tested are
``(16, 32)``, ``(64, 64)`` and ``(32, 16)``.
"""
if full is None:
full = int(os.environ.get('CUPY_TEST_FULL_COMBINATION', '0')) != 0
if full:
combination = parameterized.product({name: types for name in names})
else:
ts = []
for _ in range(len(names)):
# Make shuffled list of types for each name
t = list(types)
random.shuffle(t)
ts.append(t)
combination = [dict(zip(names, typs)) for typs in zip(*ts)]
def decorator(impl):
@functools.wraps(impl)
def test_func(self, *args, **kw):
for dtypes in combination:
kw_copy = kw.copy()
kw_copy.update(dtypes)
try:
impl(self, *args, **kw_copy)
except Exception:
print(dtypes)
raise
return test_func
return decorator
def for_dtypes_combination(types, names=('dtype', ), full=None):
"""Decorator that checks the fixture with a product set of dtypes.
Args:
types(list of dtypes): dtypes to be tested.
names(list of str): Argument names to which dtypes are passed.
full(bool): If ``True``, then all combinations
of dtypes will be tested.
Otherwise, the subset of combinations will be tested
(see the description below).
Decorator adds the keyword arguments specified by ``names``
to the test fixture. Then, it runs the fixtures in parallel
with passing (possibly a subset of) the product set of dtypes.
The range of dtypes is specified by ``types``.
The combination of dtypes to be tested changes depending
on the option ``full``. If ``full`` is ``True``,
all combinations of ``types`` are tested.
Sometimes, such an exhaustive test can be costly.
So, if ``full`` is ``False``, only the subset of possible
combinations is tested. Specifically, at first,
the shuffled lists of ``types`` are made for each argument
name in ``names``.
Let the lists be ``D1``, ``D2``, ..., ``Dn``
where :math:`n` is the number of arguments.
Then, the combinations to be tested will be ``zip(D1, ..., Dn)``.
If ``full`` is ``None``, the behavior is switched
by setting the environment variable ``CUPY_TEST_FULL_COMBINATION=1``.
For example, let ``types`` be ``[float16, float32, float64]``
and ``names`` be ``['a_type', 'b_type']``. If ``full`` is ``True``,
then the decorated test fixture is executed with all
:math:`2^3` patterns. On the other hand, if ``full`` is ``False``,
shuffled lists are made for ``a_type`` and ``b_type``.
Suppose the lists are ``(16, 64, 32)`` for ``a_type`` and
``(32, 64, 16)`` for ``b_type`` (prefixes are removed for short).
Then the combinations of ``(a_type, b_type)`` to be tested are
``(16, 32)``, ``(64, 64)`` and ``(32, 16)``.
"""
if full is None:
full = int(os.environ.get('CUPY_TEST_FULL_COMBINATION', '0')) != 0
if full:
combination = parameterized.product({name: types for name in names})
else:
ts = []
for _ in range(len(names)):
# Make shuffled list of types for each name
t = list(types)
random.shuffle(t)
ts.append(t)
combination = [dict(zip(names, typs)) for typs in zip(*ts)]
def decorator(impl):
@functools.wraps(impl)
def test_func(self, *args, **kw):
for dtypes in combination:
kw_copy = kw.copy()
kw_copy.update(dtypes)
try:
impl(self, *args, **kw_copy)
except Exception:
print(dtypes)
raise
return test_func
return decorator