class TestSparse:
basic_options = FalkonOptions(debug=True,
compute_arch_speed=False,
max_cpu_mem=max_mem_sparse,
max_gpu_mem=max_mem_sparse)
# sparse_dim and sparse_density result in sparse matrices with m and n non-zero entries.
sparse_dim = 10_000
sparse_density = 1e-4
@pytest.fixture(scope="class")
def s_A(self):
A = gen_sparse_matrix(n,
self.sparse_dim,
np.float64,
density=self.sparse_density,
seed=14)
Ad = torch.from_numpy(A.to_scipy().todense())
return A, Ad
@pytest.fixture(scope="class")
def s_B(self):
B = gen_sparse_matrix(m,
self.sparse_dim,
np.float64,
density=self.sparse_density,
seed=14)
Bd = torch.from_numpy(B.to_scipy().todense())
return B, Bd
@pytest.fixture(scope="class")
def s_gram(self, kernel, s_A, s_B):
opt = FalkonOptions(use_cpu=True, compute_arch_speed=False)
return kernel(s_A[1], s_B[1], opt=opt) # n x m kernel
@pytest.fixture(scope="class")
def s_expected_fmmv(self, s_gram, v):
return s_gram @ v
@pytest.fixture(scope="class")
def s_e_dfmmv1(self, s_gram, v, w):
return s_gram.T @ (s_gram @ v + w)
@pytest.fixture(scope="class")
def s_e_dfmmv2(self, s_gram, v):
return s_gram.T @ (s_gram @ v)
@pytest.fixture(scope="class")
def s_e_dfmmv3(self, s_gram, w):
return s_gram.T @ w
@pytest.fixture(scope="class")
def s_e_dfmmv(self, request):
return request.getfixturevalue(request.param)
@pytest.mark.parametrize("cpu", cpu_params, ids=["cpu", "gpu"])
@pytest.mark.parametrize(
"Adt,Bdt,vo,vdt", [
(np.float32, np.float32, "F", np.float32),
(np.float32, np.float32, "C", np.float32),
(np.float64, np.float64, "F", np.float64),
(np.float64, np.float64, "C", np.float64),
],
ids=["A32-B32-vF32", "A32-B32-vC32", "A64-B64-vF64", "A64-B64-vC64"])
def test_fmmv(self, s_A, s_B, v, Adt, Bdt, vo, vdt, kernel,
s_expected_fmmv, cpu):
A = fix_sparse_mat(s_A[0], dtype=Adt)
B = fix_sparse_mat(s_B[0], dtype=Bdt)
v = fix_mat(v, dtype=vdt, order=vo, copy=True)
opt = dataclasses.replace(self.basic_options, use_cpu=cpu)
rtol = choose_on_dtype(A.dtype)
# Test normal
_run_fmmv_test(kernel.mmv,
s_expected_fmmv, (A, B, v),
out=None,
rtol=rtol,
opt=opt)
# Test with out
out = torch.empty(A.shape[0], v.shape[1], dtype=A.dtype)
_run_fmmv_test(kernel.mmv,
s_expected_fmmv, (A, B, v),
out=out,
rtol=rtol,
opt=opt)
@pytest.mark.skipif(not decide_cuda(), reason="No GPU found.")
@pytest.mark.parametrize("Adt,Bdt,vo,vdt",
[(np.float32, np.float32, "F", np.float32)],
ids=["A32-B32-vF32"])
@pytest.mark.xfail(reason="Squared-norm not implemented for CUDA tensors",
run=True)
def test_fmmv_input_device(self, s_A, s_B, v, Adt, Bdt, vo, vdt, kernel,
s_expected_fmmv):
input_device = "cuda:0"
A = fix_sparse_mat(s_A[0], dtype=Adt, device=input_device)
B = fix_sparse_mat(s_B[0], dtype=Bdt, device=input_device)
v = fix_mat(v, dtype=vdt, order=vo, copy=True, device=input_device)
opt = dataclasses.replace(self.basic_options, use_cpu=False)
rtol = choose_on_dtype(A.dtype)
# Test normal
_run_fmmv_test(kernel.mmv,
s_expected_fmmv, (A, B, v),
out=None,
rtol=rtol,
opt=opt)
# Test with out
out = torch.empty(A.shape[0],
v.shape[1],
dtype=A.dtype,
device=input_device)
_run_fmmv_test(kernel.mmv,
s_expected_fmmv, (A, B, v),
out=out,
rtol=rtol,
opt=opt)
@pytest.mark.parametrize("cpu", cpu_params, ids=["cpu", "gpu"])
@pytest.mark.parametrize(
"Adt,Bdt,vo,vdt,wo,wdt,s_e_dfmmv",
[
pytest.param(n32,
n32,
"F",
n32,
"F",
n32,
"s_e_dfmmv1",
marks=mark.usefixtures("s_e_dfmmv1")),
pytest.param(n32,
n32,
"C",
n32,
"C",
n32,
"s_e_dfmmv1",
marks=mark.usefixtures("s_e_dfmmv1")),
pytest.param(n64,
n64,
"F",
n64,
"F",
n64,
"s_e_dfmmv1",
marks=mark.usefixtures("s_e_dfmmv1")),
pytest.param(n64,
n64,
"C",
n64,
"C",
n64,
"s_e_dfmmv1",
marks=mark.usefixtures("s_e_dfmmv1")),
pytest.param(n32,
n32,
"F",
n32,
None,
None,
"s_e_dfmmv2",
marks=mark.usefixtures("s_e_dfmmv2")),
pytest.param(n32,
n32,
"C",
n32,
None,
None,
"s_e_dfmmv2",
marks=mark.usefixtures("s_e_dfmmv2")),
pytest.param(n64,
n64,
"F",
n64,
None,
None,
"s_e_dfmmv2",
marks=mark.usefixtures("s_e_dfmmv2")),
pytest.param(n64,
n64,
"C",
n64,
None,
None,
"s_e_dfmmv2",
marks=mark.usefixtures("s_e_dfmmv2")),
pytest.param(n32,
n32,
None,
None,
"F",
n32,
"s_e_dfmmv3",
marks=mark.usefixtures("s_e_dfmmv3")),
pytest.param(n32,
n32,
None,
None,
"C",
n32,
"s_e_dfmmv3",
marks=mark.usefixtures("s_e_dfmmv3")),
pytest.param(n64,
n64,
None,
None,
"F",
n64,
"s_e_dfmmv3",
marks=mark.usefixtures("s_e_dfmmv3")),
pytest.param(n64,
n64,
None,
None,
"C",
n64,
"s_e_dfmmv3",
marks=mark.usefixtures("s_e_dfmmv3")),
# A few mixed-contiguity examples
pytest.param(n32,
n32,
"C",
n32,
"F",
n32,
"s_e_dfmmv1",
marks=mark.usefixtures("s_e_dfmmv1")),
],
ids=[
"32-32-vF32-wF32", "32-32-vC32-wC32", "64-64-vF64-wF64",
"64-64-vC64-wC64", "32-32-vF32", "32-32-vC32", "64-64-vF64",
"64-64-vC64", "32-32-wF32", "32-32-wC32", "64-64-wF64",
"64-64-wC64", "32-32-vC32-wF32"
],
indirect=["s_e_dfmmv"])
def test_dfmmv(self, s_A, s_B, v, w, Adt, Bdt, vo, vdt, wo, wdt, kernel,
s_e_dfmmv, cpu):
A = fix_sparse_mat(s_A[0], dtype=Adt)
B = fix_sparse_mat(s_B[0], dtype=Bdt)
v = fix_mat(v, order=vo, dtype=vdt)
w = fix_mat(w, order=wo, dtype=wdt)
opt = dataclasses.replace(self.basic_options, use_cpu=cpu)
rtol = choose_on_dtype(A.dtype)
# Test normal
_run_fmmv_test(kernel.dmmv,
s_e_dfmmv, (A, B, v, w),
out=None,
rtol=rtol,
opt=opt)
# Test with out
out = torch.empty(m, t, dtype=A.dtype)
_run_fmmv_test(kernel.dmmv,
s_e_dfmmv, (A, B, v, w),
out=out,
rtol=rtol,
opt=opt)
@pytest.mark.skipif(not decide_cuda(), reason="No GPU found.")
@pytest.mark.xfail(reason="Squared-norm not implemented for CUDA tensors",
run=True)
@pytest.mark.parametrize(
"Adt,Bdt,vo,vdt,wo,wdt,s_e_dfmmv", [
pytest.param(n32,
n32,
"F",
n32,
"F",
n32,
"s_e_dfmmv1",
marks=mark.usefixtures("s_e_dfmmv1")),
pytest.param(n32,
n32,
"F",
n32,
None,
None,
"s_e_dfmmv2",
marks=mark.usefixtures("s_e_dfmmv2")),
pytest.param(n32,
n32,
None,
None,
"F",
n32,
"s_e_dfmmv3",
marks=mark.usefixtures("s_e_dfmmv3")),
],
ids=["32-32-vF32-wF32", "32-32-vF32", "32-32-wF32"],
indirect=["s_e_dfmmv"])
def test_dfmmv_input_devices(self, s_A, s_B, v, w, Adt, Bdt, vo, vdt, wo,
wdt, kernel, s_e_dfmmv):
input_device = "cuda:0"
A = fix_sparse_mat(s_A[0], dtype=Adt, device=input_device)
B = fix_sparse_mat(s_B[0], dtype=Bdt, device=input_device)
v = fix_mat(v, order=vo, dtype=vdt, device=input_device)
w = fix_mat(w, order=wo, dtype=wdt, device=input_device)
opt = dataclasses.replace(self.basic_options, use_cpu=False)
rtol = choose_on_dtype(A.dtype)
# Test normal
_run_fmmv_test(kernel.dmmv,
s_e_dfmmv, (A, B, v, w),
out=None,
rtol=rtol,
opt=opt)
# Test with out
out = torch.empty(m, t, dtype=A.dtype, device=input_device)
_run_fmmv_test(kernel.dmmv,
s_e_dfmmv, (A, B, v, w),
out=out,
rtol=rtol,
opt=opt)
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
"""Unit tests for `grizzly.reduce.main`."""
from unittest.mock import Mock
from pytest import mark, raises
from ..common.storage import TestCase, TestCaseLoadFailure
from ..common.utils import Exit
from ..target import AssetManager, TargetLaunchError, TargetLaunchTimeout
from . import ReduceManager
from .args import ReduceArgs, ReduceFuzzManagerIDArgs, ReduceFuzzManagerIDQualityArgs
from .exceptions import GrizzlyReduceBaseException
pytestmark = mark.usefixtures(
"tmp_path_fm_config",
"tmp_path_replay_status_db",
"tmp_path_reduce_status_db",
)
def test_args_01(capsys, tmp_path, mocker):
"""test args in common with grizzly.replay"""
# pylint: disable=import-outside-toplevel
from ..replay.test_args import test_replay_args_01 as real_test
mocker.patch("grizzly.replay.test_args.ReplayArgs", new=ReduceArgs)
real_test(capsys, mocker, tmp_path)
def test_args_02(tmp_path):
"""test parsing args specific to grizzly.reduce"""
in_file_name = join(temp_dir, filename)
return in_file_name
@fixture()
def out_file(temp_dir, filename='from_python_tester'):
return join(temp_dir, filename)
@fixture()
def in_file_contents(): return "generic_fcn_name,--,for in file"
@fixture()
def initialize_infile(in_file, in_file_contents):
with open(in_file, 'w') as f:
f.write(in_file_contents)
pytestmark = mark.usefixtures('initialize_infile')
def my_fcn1(arg): return 'my_fcn1 called with argument %s' % arg
def my_fcn2(arg): return 'my_fcn2 called with argument %s' % arg
@fixture()
def cd1():
cd = CommandDispatcher()
cd.generic_fcn_name = my_fcn1
return cd
@fixture()
def cd2(cd1):
cd = CommandDispatcher()
cd.generic_fcn_name = my_fcn2
cd.cd1 = cd1
class TestDense:
basic_options = FalkonOptions(debug=True,
compute_arch_speed=False,
keops_active="no",
max_gpu_mem=max_mem_dense,
max_cpu_mem=max_mem_dense)
@pytest.mark.parametrize(
"Ao,Adt,Bo,Bdt,vo,vdt",
[
("F", np.float32, "F", np.float32, "F", np.float32),
("C", np.float32, "C", np.float32, "C", np.float32),
("F", np.float64, "F", np.float64, "F", np.float64),
("C", np.float64, "C", np.float64, "C", np.float64),
# A few mixed-contiguity examples
("F", np.float32, "C", np.float32, "F", np.float32),
("F", np.float32, "C", np.float32, "C", np.float32),
],
ids=[
"AF32-BF32-vF32", "AC32-BC32-vC32", "AF64-BF64-vF64",
"AC64-BC64-vC64", "AF32-BC32-vF32", "AF32-BC32-vC32"
])
@pytest.mark.parametrize("cpu", cpu_params, ids=["cpu", "gpu"])
def test_fmmv(self, A, B, v, Ao, Adt, Bo, Bdt, vo, vdt, kernel,
expected_fmmv, cpu):
A = fix_mat(A, order=Ao, dtype=Adt)
B = fix_mat(B, order=Bo, dtype=Bdt)
v = fix_mat(v, order=vo, dtype=vdt)
opt = dataclasses.replace(self.basic_options, use_cpu=cpu)
rtol = choose_on_dtype(A.dtype)
# Test normal
_run_fmmv_test(kernel.mmv,
expected_fmmv, (A, B, v),
out=None,
rtol=rtol,
opt=opt)
# Test with out
out = torch.empty(A.shape[0], v.shape[1], dtype=A.dtype)
_run_fmmv_test(kernel.mmv,
expected_fmmv, (A, B, v),
out=out,
rtol=rtol,
opt=opt)
@pytest.mark.skipif(not decide_cuda(), reason="No GPU found.")
@pytest.mark.parametrize("Ao,Adt,Bo,Bdt,vo,vdt", [
("F", np.float32, "F", np.float32, "F", np.float32),
],
ids=["AF32-BF32-vF32"])
def test_fmmv_input_device(self, A, B, v, Ao, Adt, Bo, Bdt, vo, vdt,
kernel, expected_fmmv):
input_device = "cuda:0"
A = fix_mat(A, order=Ao, dtype=Adt, device=input_device)
B = fix_mat(B, order=Bo, dtype=Bdt, device=input_device)
v = fix_mat(v, order=vo, dtype=vdt, device=input_device)
opt = dataclasses.replace(self.basic_options, use_cpu=False)
rtol = choose_on_dtype(A.dtype)
# Test normal
_run_fmmv_test(kernel.mmv,
expected_fmmv, (A, B, v),
out=None,
rtol=rtol,
opt=opt)
# Test with out
out = torch.empty(A.shape[0],
v.shape[1],
dtype=A.dtype,
device=input_device)
_run_fmmv_test(kernel.mmv,
expected_fmmv, (A, B, v),
out=out,
rtol=rtol,
opt=opt)
@pytest.mark.parametrize("cpu", cpu_params, ids=["cpu", "gpu"])
@pytest.mark.parametrize(
"Ao,Adt,Bo,Bdt,vo,vdt,wo,wdt,e_dfmmv",
[
pytest.param("F",
n32,
"F",
n32,
"F",
n32,
"F",
n32,
"e_dfmmv1",
marks=mark.usefixtures("e_dfmmv1")),
pytest.param("C",
n32,
"C",
n32,
"C",
n32,
"C",
n32,
"e_dfmmv1",
marks=mark.usefixtures("e_dfmmv1")),
pytest.param("F",
n64,
"F",
n64,
"F",
n64,
"F",
n64,
"e_dfmmv1",
marks=mark.usefixtures("e_dfmmv1")),
pytest.param("C",
n64,
"C",
n64,
"C",
n64,
"C",
n64,
"e_dfmmv1",
marks=mark.usefixtures("e_dfmmv1")),
pytest.param("F",
n32,
"F",
n32,
"F",
n32,
None,
None,
"e_dfmmv2",
marks=mark.usefixtures("e_dfmmv2")),
pytest.param("C",
n32,
"C",
n32,
"C",
n32,
None,
None,
"e_dfmmv2",
marks=mark.usefixtures("e_dfmmv2")),
pytest.param("F",
n64,
"F",
n64,
"F",
n64,
None,
None,
"e_dfmmv2",
marks=mark.usefixtures("e_dfmmv2")),
pytest.param("C",
n64,
"C",
n64,
"C",
n64,
None,
None,
"e_dfmmv2",
marks=mark.usefixtures("e_dfmmv2")),
pytest.param("F",
n32,
"F",
n32,
None,
None,
"F",
n32,
"e_dfmmv3",
marks=mark.usefixtures("e_dfmmv3")),
pytest.param("C",
n32,
"C",
n32,
None,
None,
"C",
n32,
"e_dfmmv3",
marks=mark.usefixtures("e_dfmmv3")),
pytest.param("F",
n64,
"F",
n64,
None,
None,
"F",
n64,
"e_dfmmv3",
marks=mark.usefixtures("e_dfmmv3")),
pytest.param("C",
n64,
"C",
n64,
None,
None,
"C",
n64,
"e_dfmmv3",
marks=mark.usefixtures("e_dfmmv3")),
# A few mixed-contiguity examples
pytest.param("F",
n32,
"C",
n32,
"C",
n32,
"F",
n32,
"e_dfmmv1",
marks=mark.usefixtures("e_dfmmv1")),
],
ids=[
"F32-F32-vF32-wF32", "C32-C32-vC32-wC32", "F64-F64-vF64-wF64",
"C64-C64-vC64-wC64", "F32-F32-vF32", "C32-C32-vC32",
"F64-F64-vF64", "C64-C64-vC64", "F32-F32-wF32", "C32-C32-wC32",
"F64-F64-wF64", "C64-C64-wC64", "F32-C32-vC32-wF32"
],
indirect=["e_dfmmv"])
def test_dfmmv(self, A, B, v, w, Ao, Adt, Bo, Bdt, vo, vdt, wo, wdt,
kernel, e_dfmmv, cpu):
A = fix_mat(A, order=Ao, dtype=Adt)
B = fix_mat(B, order=Bo, dtype=Bdt)
v = fix_mat(v, order=vo, dtype=vdt)
w = fix_mat(w, order=wo, dtype=wdt)
opt = dataclasses.replace(self.basic_options, use_cpu=cpu)
rtol = choose_on_dtype(A.dtype)
# Test normal
_run_fmmv_test(kernel.dmmv,
e_dfmmv, (A, B, v, w),
out=None,
rtol=rtol,
opt=opt)
# Test with out
out = torch.empty(m, t, dtype=A.dtype)
_run_fmmv_test(kernel.dmmv,
e_dfmmv, (A, B, v, w),
out=out,
rtol=rtol,
opt=opt)
@pytest.mark.parametrize(
"Ao,Adt,Bo,Bdt,vo,vdt,wo,wdt,e_dfmmv", [
pytest.param("F",
n32,
"F",
n32,
"F",
n32,
"F",
n32,
"e_dfmmv1",
marks=mark.usefixtures("e_dfmmv1")),
pytest.param("F",
n32,
"F",
n32,
"F",
n32,
None,
None,
"e_dfmmv2",
marks=mark.usefixtures("e_dfmmv2")),
pytest.param("F",
n32,
"F",
n32,
None,
None,
"F",
n32,
"e_dfmmv3",
marks=mark.usefixtures("e_dfmmv3"))
],
ids=["F32-F32-vF32-wF32", "F32-F32-vF32", "F32-F32-wF32"],
indirect=["e_dfmmv"])
@pytest.mark.skipif(not decide_cuda(), reason="No GPU found.")
def test_dfmmv_input_device(self, A, B, v, w, Ao, Adt, Bo, Bdt, vo, vdt,
wo, wdt, kernel, e_dfmmv):
input_device = "cuda:0"
A = fix_mat(A, order=Ao, dtype=Adt, device=input_device)
B = fix_mat(B, order=Bo, dtype=Bdt, device=input_device)
v = fix_mat(v, order=vo, dtype=vdt, device=input_device)
w = fix_mat(w, order=wo, dtype=wdt, device=input_device)
opt = dataclasses.replace(self.basic_options, use_cpu=False)
rtol = choose_on_dtype(A.dtype)
# Test normal
_run_fmmv_test(kernel.dmmv,
e_dfmmv, (A, B, v, w),
out=None,
rtol=rtol,
opt=opt)
# Test with out
out = torch.empty(m, t, dtype=A.dtype, device=input_device)
_run_fmmv_test(kernel.dmmv,
e_dfmmv, (A, B, v, w),
out=out,
rtol=rtol,
opt=opt)
@pytest.mark.skipif(not decide_cuda(), reason="No GPU found.")
def test_incorrect_dev_setting(self, A, B, v, w, kernel, e_dfmmv1,
expected_fmmv):
# tests when use_cpu = True, but CUDA input tensors
A = A.cuda()
B = B.cuda()
v = v.cuda()
w = w.cuda()
opt = dataclasses.replace(self.basic_options, use_cpu=True)
rtol = choose_on_dtype(A.dtype)
with pytest.warns(
UserWarning,
match=
'backend was chosen to be CPU, but GPU input tensors found'):
_run_fmmv_test(kernel.dmmv,
e_dfmmv1, (A, B, v, w),
out=None,
rtol=rtol,
opt=opt)
with pytest.warns(
UserWarning,
match=
'backend was chosen to be CPU, but GPU input tensors found'):
_run_fmmv_test(kernel.mmv,
expected_fmmv, (A, B, v),
out=None,
rtol=rtol,
opt=opt)
def rp(request):
process = BottleServer(ResourceProviderMock(access_tokens[0]),
port=rp_port)
process.start()
request.addfinalizer(process.terminate)
@fixture(scope='module')
def http():
class HttpClient(requests.Session):
def request(self, method, uri, **kwargs):
url = urljoin(nginx_base_uri, uri)
defaults = {'allow_redirects': False, 'verify': False}
return super().request(method, url,
**merge_dicts(defaults, kwargs))
# Original get method sets allow_redirects to True, so we must override it.
def get(self, url, **kwargs):
return self.request('GET', url, **kwargs)
return HttpClient()
@fixture
def logged_in_fixture(http):
http.post('/_oauth/login', allow_redirects=True)
assert len(http.cookies) == 3
logged_in = mark.usefixtures('logged_in_fixture')
from pytest import mark, raises
from sapphire import Sapphire
from ..common.reporter import Report
from ..common.storage import TestCase
from ..replay import ReplayResult
from ..target import AssetManager, Target
from . import ReduceManager
from .strategies import Strategy, _load_strategies
LOG = getLogger(__name__)
pytestmark = mark.usefixtures(
"reporter_sequential_strftime",
"tmp_path_fm_config",
"tmp_path_replay_status_db",
"tmp_path_reduce_status_db",
)
@mark.parametrize("is_hang", [True, False])
def test_strategy_tc_load(is_hang):
"""test that strategy base class dump and load doesn't change testcase metadata"""
class _TestStrategy(Strategy):
def __iter__(self):
yield TestCase.load(str(self._testcase_root), False)
def update(self, success, served=None):
pass
from pdb import set_trace as bp
from pytest import fixture, mark
from flask import current_app
from .utils import is_in
from .db_utils import add_note, add_user
import json
import tireta
import json
import random
import string
from .conftest import build_user_payload, build_note_payload
# reset db before each test
pytestmark = mark.usefixtures("reset_db")
# ---------------------CLIENT--------------------------
def test_client_exist(client):
assert client is not None
# ---------------------USER--------------------------
def test_user_resource_exist(client):
response = client.get('/api/users')
assert response.status_code == 200
def test_test_start_with_no_user(client):
"""
unit tests for grizzly.Session
"""
from itertools import chain, count, repeat
from pytest import mark, raises
from sapphire import Sapphire, Served
from .adapter import Adapter
from .common.reporter import Report, Reporter
from .common.runner import RunResult
from .session import LogOutputLimiter, Session, SessionError
from .target import AssetManager, Result, Target, TargetLaunchError
pytestmark = mark.usefixtures("patch_collector", "tmp_path_status_db")
class SimpleAdapter(Adapter):
def __init__(self, use_harness, remaining=None):
super().__init__("simple")
self.remaining = remaining
self._use_harness = use_harness
def setup(self, input_path, _server_map):
if self._use_harness:
self.enable_harness()
self.fuzz["input"] = input_path
def generate(self, testcase, _server_map):
assert testcase.adapter_name == self.name
class TestSparse:
basic_options = FalkonOptions(debug=True, compute_arch_speed=False)
@pytest.mark.parametrize("Adt,Bdt,vo,vdt", [
(np.float32, np.float32, "F", np.float32),
(np.float32, np.float32, "C", np.float32),
(np.float64, np.float64, "F", np.float64),
(np.float64, np.float64, "C", np.float64),
], ids=["A32-B32-vF32", "A32-B32-vC32", "A64-B64-vF64", "A64-B64-vC64"])
@pytest.mark.parametrize("max_mem", [2 * 2 ** 20])
def test_fmmv(self, getA, getB, getv, Adt, Bdt, vo, vdt, kernel,
s_expected_fmmv, max_mem, cpu):
A = getA(dtype=Adt, sparse=True)
B = getB(dtype=Bdt, sparse=True)
v = getv(order=vo, dtype=vdt)
opt = dataclasses.replace(self.basic_options, use_cpu=cpu, max_cpu_mem=max_mem, max_gpu_mem=max_mem)
rtol = choose_on_dtype(A.dtype)
# Test normal
_run_fmmv_test(kernel.mmv, s_expected_fmmv, (A, B, v), out=None, rtol=rtol, opt=opt)
# Test with out
out = torch.empty(A.shape[0], v.shape[1], dtype=A.dtype)
_run_fmmv_test(kernel.mmv, s_expected_fmmv, (A, B, v), out=out, rtol=rtol, opt=opt)
@pytest.mark.parametrize("Adt,Bdt,vo,vdt,wo,wdt,s_e_dfmmv", [
pytest.param(n32, n32, "F", n32, "F", n32, "s_e_dfmmv1", marks=mark.usefixtures("s_e_dfmmv1")),
pytest.param(n32, n32, "C", n32, "C", n32, "s_e_dfmmv1", marks=mark.usefixtures("s_e_dfmmv1")),
pytest.param(n64, n64, "F", n64, "F", n64, "s_e_dfmmv1", marks=mark.usefixtures("s_e_dfmmv1")),
pytest.param(n64, n64, "C", n64, "C", n64, "s_e_dfmmv1", marks=mark.usefixtures("s_e_dfmmv1")),
pytest.param(n32, n32, "F", n32, None, None, "s_e_dfmmv2", marks=mark.usefixtures("s_e_dfmmv2")),
pytest.param(n32, n32, "C", n32, None, None, "s_e_dfmmv2", marks=mark.usefixtures("s_e_dfmmv2")),
pytest.param(n64, n64, "F", n64, None, None, "s_e_dfmmv2", marks=mark.usefixtures("s_e_dfmmv2")),
pytest.param(n64, n64, "C", n64, None, None, "s_e_dfmmv2", marks=mark.usefixtures("s_e_dfmmv2")),
pytest.param(n32, n32, None, None, "F", n32, "s_e_dfmmv3", marks=mark.usefixtures("s_e_dfmmv3")),
pytest.param(n32, n32, None, None, "C", n32, "s_e_dfmmv3", marks=mark.usefixtures("s_e_dfmmv3")),
pytest.param(n64, n64, None, None, "F", n64, "s_e_dfmmv3", marks=mark.usefixtures("s_e_dfmmv3")),
pytest.param(n64, n64, None, None, "C", n64, "s_e_dfmmv3", marks=mark.usefixtures("s_e_dfmmv3")),
# A few mixed-contiguity examples
pytest.param(n32, n32, "C", n32, "F", n32, "s_e_dfmmv1", marks=mark.usefixtures("s_e_dfmmv1")),
], ids=["32-32-vF32-wF32", "32-32-vC32-wC32", "64-64-vF64-wF64", "64-64-vC64-wC64",
"32-32-vF32", "32-32-vC32", "64-64-vF64", "64-64-vC64",
"32-32-wF32", "32-32-wC32", "64-64-wF64", "64-64-wC64",
"32-32-vC32-wF32"
],
indirect=["s_e_dfmmv"])
@pytest.mark.parametrize("max_mem", [2 * 2 ** 20])
def test_dfmmv(self, getA, getB, getv, getw, Adt, Bdt, vo, vdt, wo, wdt, kernel,
s_e_dfmmv, max_mem, cpu, m, t):
A = getA(dtype=Adt, sparse=True)
B = getB(dtype=Bdt, sparse=True)
v = getv(order=vo, dtype=vdt)
w = getw(order=wo, dtype=wdt)
opt = dataclasses.replace(self.basic_options, use_cpu=cpu, max_cpu_mem=max_mem, max_gpu_mem=max_mem)
rtol = choose_on_dtype(A.dtype)
# Test normal
_run_fmmv_test(kernel.dmmv, s_e_dfmmv, (A, B, v, w), out=None, rtol=rtol, opt=opt)
# Test with out
out = torch.empty(m, t, dtype=A.dtype)
_run_fmmv_test(kernel.dmmv, s_e_dfmmv, (A, B, v, w), out=out, rtol=rtol, opt=opt)
# applying fixture to all test in a module
from pytest import fixture, mark
@fixture(scope='module')
def meta_fixture():
print()
print('=== begin meta fixture')
yield
print()
print('=== end meta fixture')
# apply this fixture to everything in this module
pytestmark = mark.usefixtures('meta_fixture')
def test_with_meta_fixtures_a():
print()
print('running test with meta fixtures a')
def test_with_meta_fixtures_b():
print()
print('running test with meta fixtures b')
# marked_meta_fixtures.py::test_with_meta_fixtures_a
# === begin meta fixture
#
marker = request.node.get_marker('oaas_config')
extra_conf = marker.kwargs if marker else {}
config = merge_dicts(proxy_conf, oaas_state, extra_conf)
process = BottleServer(OAuthServerMock(config), port=oaas_port)
process.start()
request.addfinalizer(process.terminate)
@fixture(scope='module')
def http():
class HttpClient(requests.Session):
def request(self, method, uri, **kwargs):
url = urljoin(nginx_base_uri, uri)
defaults = {'allow_redirects': False, 'verify': False}
return super().request(method, url, **merge_dicts(defaults, kwargs))
# Original get method sets allow_redirects to True, so we must override it.
def get(self, url, **kwargs):
return self.request('GET', url, **kwargs)
return HttpClient()
@fixture
def logged_in_fixture(http):
http.get('/_oauth/login', allow_redirects=True)
assert len(http.cookies) == 3
logged_in = mark.usefixtures('logged_in_fixture')
"""
unit tests for grizzly.replay
"""
from itertools import cycle
from pathlib import Path
from pytest import mark, raises
from sapphire import Sapphire, Served
from ..common.reporter import Report
from ..common.storage import TestCase, TestCaseLoadFailure
from ..target import AssetManager, Result, Target
from .replay import ReplayManager, ReplayResult
pytestmark = mark.usefixtures("patch_collector", "tmp_path_grz_tmp",
"tmp_path_replay_status_db")
def _fake_save_logs(result_logs, _meta=False):
"""write fake log data to disk"""
log_path = Path(result_logs)
(log_path / "log_stderr.txt").write_text("STDERR log\n")
(log_path / "log_stdout.txt").write_text("STDOUT log\n")
with (log_path / "log_asan_blah.txt").open("w") as log_fp:
log_fp.write("==1==ERROR: AddressSanitizer: ")
log_fp.write("SEGV on unknown address 0x0 (pc 0x0 bp 0x0 sp 0x0 T0)\n")
log_fp.write(" #0 0xbad000 in foo /file1.c:123:234\n")
log_fp.write(" #1 0x1337dd in bar /file2.c:1806:19\n")
def test_replay_01(mocker):
from pytest import fixture, mark
from sqlalchemy import text
pytestmark = mark.usefixtures("db_migration")
@fixture(scope="session")
def alembic_ini_path():
return "./tests/alembic.ini"
def test_it(session):
session.execute(text("select * from testuser"))
from pytest import fixture, mark
@fixture(scope="module")
def meta_fixture():
print("\n*** begin meta_fixture ***")
yield
print("\n*** end meta_fixture ***")
# Apply this fixture to everything in this module!
pytestmark = mark.usefixtures("meta_fixture")
def test_with_meta_fixtures_a():
print("\n Running test_with_meta_fixtures_a")
def test_with_meta_fixtures_b():
print("\n Running test_with_meta_fixtures_b")
# How could we tell meta_fixture to only run once, "around" our tests?
# (See 16_scoped_and_meta_fixtures_test.py for a hint...)
extra_conf = marker.kwargs if marker else {}
config = merge_dicts(proxy_conf, oaas_state, extra_conf)
process = BottleServer(OAuthServerMock(config), port=oaas_port)
process.start()
request.addfinalizer(process.terminate)
@fixture(scope="module")
def http():
class HttpClient(requests.Session):
def request(self, method, uri, **kwargs):
url = urljoin(nginx_base_uri, uri)
defaults = {"allow_redirects": False, "verify": False}
return super().request(method, url, **merge_dicts(defaults, kwargs))
# Original get method sets allow_redirects to True, so we must override it.
def get(self, url, **kwargs):
return self.request("GET", url, **kwargs)
return HttpClient()
@fixture
def logged_in_fixture(http):
http.post("/_oauth/login", allow_redirects=True)
assert len(http.cookies) == 3
logged_in = mark.usefixtures("logged_in_fixture")