def xfail_known_issues(request, known_issues: Dict[str, str],
config_env: Dict):
lookup_key1 = f'{request.node.originalname}:{config_env["CO"]}:{config_env["FN"]}'
lookup_key2 = f'{request.node.originalname}:{config_env["CO"]}:'
lookup_key3 = f':{config_env["CO"]}:{config_env["FN"]}'
if lookup_key1 in known_issues.keys():
request.applymarker(mark.xfail(reason=known_issues[lookup_key1]))
elif lookup_key2 in known_issues.keys():
request.applymarker(mark.xfail(reason=known_issues[lookup_key2]))
elif lookup_key3 in known_issues.keys():
request.applymarker(mark.xfail(reason=known_issues[lookup_key3]))
def pytest_runtest_setup(item):
"""Apply custom markers.
Marks:
- not implemented tests as expected to fail,
- not written tests as skipped.
"""
not_implemented = item.get_closest_marker("notimplemented")
not_written = item.get_closest_marker("notwritten")
if not_implemented:
item.add_marker(mark.xfail(reason="Not implemented"))
if not_written:
item.add_marker(mark.skip(reason="Not written"))
@mark.parametrize('reader_kwargs,compress_kwargs', [
(dict(add_references=False), dict()),
(dict(add_references=False), dict(verify=True)),
(dict(add_references=False), dict(verify=False)),
(dict(add_references=False), dict(verify=True, single_analytic=True)),
(dict(add_references=False), dict(verify=False, single_analytic=True)),
(dict(add_references=False), dict(verify=True, single_analytic=False)),
(dict(add_references=False), dict(verify=False, single_analytic=False)),
(dict(add_references=False), dict(single_analytic=False)),
(dict(add_references=False), dict(single_analytic=True)),
(dict(add_references=True), dict()),
param(
dict(add_references=True),
dict(verify=True),
marks=[mark.xfail(strict=True)],
),
(dict(add_references=True), dict(verify=False)),
param(
dict(add_references=True),
dict(verify=True, single_analytic=True),
marks=[mark.xfail(strict=True)],
),
(dict(add_references=True), dict(verify=False, single_analytic=True)),
param(
dict(add_references=True),
dict(verify=True, single_analytic=False),
marks=[mark.xfail(strict=True)],
),
(dict(add_references=True), dict(verify=False, single_analytic=False)),
(dict(add_references=True), dict(single_analytic=False)),
class TestPoint:
@mark.parametrize(
"x, y",
[
(-2.4, 0.8),
(3, -1),
param("a", 5, marks=mark.xfail(reason="str")),
param([0], 5, marks=mark.xfail(reason="list")),
param(-2, None, marks=mark.xfail(reason="None")),
],
)
def test_point_init(self, x, y):
point = Point(x, y)
assert point and point.x == x and point.y == y
def test_length_and_dim(self):
point = Point(0, 0)
assert len(point) == point.dim == 2
def test_iteration(self):
coords = (-2, 4)
point = Point(*coords)
for tcoord, pcoord in zip(coords, point):
assert tcoord == pcoord
def test_repr_str(self):
point = Point(-2, 2)
assert repr(point) == f"Point({point.x}, {point.y})"
assert str(point) == str((point.x, point.y))
@mark.parametrize(
"point1, point2, expected",
[
(Point(1, 1), Point(1, 1), True),
(Point(0, 0), Point(3, 3), False),
],
)
def test_equality(self, point1, point2, expected):
assert (point1 == point2) == expected
@mark.parametrize(
"string",
[
" 0 0 ",
" -4.7 -9.1\n",
],
)
def test_from_str(self, string):
coords = string.split()
assert Point.from_string(string) == Point(*coords)
@mark.parametrize(
"fname",
[
"good_file.txt",
param("bad_file_invalid_data.txt", marks=mark.xfail),
],
)
def test_from_file(self, fname):
fpath = sep.join(["assets", fname])
with open(fpath) as fl:
point = Point.from_string(fl.read())
assert Point.from_file(fpath) == point
@mark.parametrize(
"point1, point2, expected",
[
(Point(0, 0), Point(2, 0), 2),
(Point(0, 0), Point(1, 1), sqrt(2)),
(Point(0, 2), Point(0, -3), 5),
],
)
def test_dist(self, point1, point2, expected):
dst1 = point1.dist(point2)
dst2 = point2.dist(point1)
assert isclose(dst1, dst2)
assert isclose(dst1, expected) and isclose(dst2, expected)
def make_test_params(value: str, type_: TokenType, xfail: bool = False):
marks = mark.xfail(strict=True) if xfail else ()
return param(value, Token(type_=type_, value=value, line_number=1, position=1), marks=marks)
@mark.parametrize(
"reader_kwargs,compress_kwargs",
[
(dict(add_references=False), dict()),
(dict(add_references=False), dict(verify=True)),
(dict(add_references=False), dict(verify=False)),
(dict(add_references=False), dict(verify=True, single_analytic=True)),
(dict(add_references=False), dict(verify=False, single_analytic=True)),
(dict(add_references=False), dict(verify=True, single_analytic=False)),
(dict(add_references=False), dict(verify=False, single_analytic=False)),
(dict(add_references=False), dict(single_analytic=False)),
(dict(add_references=False), dict(single_analytic=True)),
(dict(add_references=True), dict()),
mark.xfail((dict(add_references=True), dict(verify=True)), strict=True),
(dict(add_references=True), dict(verify=False)),
mark.xfail((dict(add_references=True), dict(verify=True, single_analytic=True)), strict=True),
(dict(add_references=True), dict(verify=False, single_analytic=True)),
mark.xfail((dict(add_references=True), dict(verify=True, single_analytic=False)), strict=True),
(dict(add_references=True), dict(verify=False, single_analytic=False)),
(dict(add_references=True), dict(single_analytic=False)),
(dict(add_references=True), dict(single_analytic=True)),
],
)
def test_compress_uuids_api(reader_kwargs, compress_kwargs):
input_file = "tests/testdata/simple.tar.gz"
reader = CommunicationReader(input_file, **reader_kwargs)
it = iter(reader)
(comm, _) = it.next()
class TestFittingMeasurement(MeasurementTests):
# Test cases:
# explicit dep/indep
# check values list vs. fitter
def _source(self, param):
''' return a Constant measurement returning Lorentzian curves '''
# determine output coordinates
xs = np.linspace(-5., 5., 100)
lorentzian = lambda f0, amp=1.: Lorentzian.f(
xs, f0=f0, df=0.5, offset=0., amplitude=amp)
if param == '1d':
# 1d data
self.f0s = 1.
data = lorentzian(self.f0s)
index = pd.Float64Index(xs, name='x')
elif param == '1d/3pk':
# 1d data with multiple peaks
self.f0s = [-3., 0., 3.]
data = np.zeros_like(xs)
for f0, amp in zip(self.f0s, [0.5, 1., 0.5]):
data += lorentzian(f0, amp)
index = pd.Float64Index(xs, name='x')
elif (param == '2d>1d') or (param == '2d>1d.T'):
# 2d data with a singleton dimension
self.f0s = [0.]
data = lorentzian(*self.f0s)
if param == '2d>1d':
index = pd.MultiIndex.from_product((xs, self.f0s),
names=['x', 'f'])
else:
index = pd.MultiIndex.from_product((self.f0s, xs),
names=['f', 'x'])
elif param == '2d':
# 2d data
self.f0s = np.linspace(-3., 3., 5)
data = np.array([lorentzian(f0) for f0 in self.fs]).ravel()
index = pd.MultiIndex.from_product((xs, self.f0s),
names=['x', 'f'])
else:
raise ValueError('Unsupported number of dimensions.')
frame = pd.DataFrame({'data': data, 'reversed': data[::-1]}, index)
# generate measurement
self.npeaks = 1 if np.isscalar(self.f0s) else len(self.f0s)
return Constant(frame)
@fixture(params=('1d', '2d>1d', mark.xfail('2d'), '1d/3pk'))
def source(self, request):
''' return a Constant measurement returning Lorentzian curves '''
return self._source(request.param)
def _fitter(self, param):
''' return different fitters '''
if param == 'Lorentzian':
return Lorentzian()
else:
return PeakFind(
peak_args=dict(widths=np.logspace(-2, 0), noise_perc=10))
@fixture(params=['Lorentzian', 'PeakFind'])
def fitter(self, request):
''' return different fitters '''
return self._fitter(request.param)
@fixture(params=[
'1d-Lorentzian', '2d>1d-Lorentzian',
mark.xfail('2d-Lorentzian'), '1d-PeakFind', '2d>1d-PeakFind',
mark.xfail('2d-PeakFind'), '1d/3pk-PeakFind'
])
def measurement(self, request):
source, fitter = request.param.split('-')
return FittingMeasurement(self._source(source),
self._fitter(fitter),
plot='')
def test_fit(self, measurement):
''' check that fitting returns the expected parameter values '''
frame = measurement(output_data=True)
assert np.all(np.isclose(frame['f0'], self.f0s, atol=0.1))
def test_fit_zero_results(self):
frame = pd.DataFrame({'data': np.zeros((50, ))},
pd.Index(np.linspace(-5., 5., 50), name='x'))
source = Constant(frame)
fitter = self._fitter('PeakFind')
measurement = FittingMeasurement(source, fitter, plot=None)
with raises(ContinueIteration):
measurement()
measurement.fail_func = lambda: False
assert measurement(output_data=True) is None
@mark.parametrize('type', ['str', 'Parameter'])
def test_dep(self, type):
source = self._source('1d')
fitter = self._fitter('Lorentzian')
if type == 'str':
dep = 'reversed'
elif type == 'Parameter':
dep = source.values[-1]
with raises(ValueError):
FittingMeasurement(source, fitter, dep='invalid')
measurement = FittingMeasurement(source, fitter, dep=dep, plot='')
frame = measurement(output_data=True)
assert np.all(np.isclose(frame['f0'], -self.f0s, atol=0.1))
@mark.parametrize('type', ['str', 'Parameter'])
def test_indep(self, type):
#TODO: this should be tested with a 2d measurement
source = self._source('2d>1d.T')
fitter = self._fitter('Lorentzian')
if type == 'str':
indep = 'x'
elif type == 'Parameter':
indep = source.coordinates[-1]
with raises(ValueError):
FittingMeasurement(source, fitter, indep='invalid')
measurement = FittingMeasurement(source, fitter, indep=indep, plot='')
frame = measurement(output_data=True)
assert np.all(np.isclose(frame['f0'], self.f0s, atol=0.1))
@mark.parametrize('method,args', [('init', 'args'), ('init', 'kwargs'),
('property', 'args')])
def test_test(self, method, args):
source = self._source('1d/3pk')
fitter = self._fitter('PeakFind')
counter = CountingMeasurement()
# define test func
nfit = len(fitter.PARAMETERS)
if args == 'args':
def test(xs, ys, p_opt, p_std, p_est):
# also check args passed to test
assert xs.shape == ys.shape
assert len(p_opt) == nfit
assert len(p_std) == nfit
assert (len(p_est) == nfit) or (len(p_est) == 0)
return abs(p_opt[0]) < 1.
elif args == 'kwargs':
def test(p_opt, **kwargs):
return abs(p_opt[0]) < 1
# assign test function
if method == 'init':
with raises(TypeError):
FittingMeasurement(source, fitter, test=True)
measurement = FittingMeasurement(source,
fitter,
counter,
test=test,
plot='')
elif method == 'property':
measurement = FittingMeasurement(source, fitter, counter, plot='')
with raises(TypeError):
measurement.test = True
measurement.test = test
# one out of three peaks is selected, so fail_func is not triggered
frame = measurement(output_data=True)
assert counter.counter.get() == 0
assert np.all(frame['fit_ok'].values == [0, 1, 0])
@mark.parametrize('method', ['init', 'property'])
def test_fail_func_exception(self, method):
source = self._source('1d')
fitter = self._fitter('Lorentzian')
test = lambda **kwargs: False
# assign fail_func
if method == 'init':
measurement = FittingMeasurement(source,
fitter,
test=test,
plot='',
fail_func=StopIteration)
elif method == 'property':
measurement = FittingMeasurement(source,
fitter,
test=test,
plot='')
measurement.fail_func = StopIteration
# fail
with raises(StopIteration):
measurement()
def test_fail_func_callable(self):
source = self._source('1d')
fitter = self._fitter('Lorentzian')
test = lambda **kwargs: False
# build fail_func
self.fails = 0
def fail_func(*args):
self.fails += 1
measurement = FittingMeasurement(source,
fitter,
test=test,
plot='',
fail_func=fail_func)
measurement()
assert self.fails == 1
def test_parameter_set(self, measurement):
''' check setting of .values and popt_out '''
# add a nested measurement that measures f0 in two different ways
f0_out = Parameter('f0_out')
pm = ParameterMeasurement(measurement.values['f0'], f0_out, name='pm')
measurement.measurements.append(pm)
measurement.popt_out = {f0_out: 'f0'}
# run fitter
store = measurement()
ref_frame = store['/Fit']
frame = store['/pm']
# check for FittingMeasurement.values.set
assert np.all(frame['f0'].values == ref_frame['f0'])
# check for popt_out working
assert np.all(frame['f0_out'].values == ref_frame['f0'])
@mark.parametrize('method', ['append', 'assign'])
def test_nested(self, measurement, method):
''' check that nested measurements are run '''
m = CountingMeasurement()
if method == 'append':
measurement.measurements.append(m)
elif method == 'assign':
measurement.measurements = [m]
measurement()
# assert that the nested measurement was called once for each peak
assert m.counter.get() == self.npeaks - 1
@mark.parametrize('array, raises', [(False, BreakIteration),
(False, ContinueIteration),
(True, BreakIteration),
(True, ContinueIteration)],
ids=['break', 'continue', '(break)', '(continue)'])
def test_nested_loop_control(self, array, raises):
''' raise loop control exception in a nested measurement,
nested measurement may be a single measurement or an array '''
m1 = CountingMeasurement(raises=raises, raise_count=1)
m2 = CountingMeasurement()
ms = [m1, m2] if array else m1
fit = FittingMeasurement(self._source('1d/3pk'),
self._fitter('PeakFind'),
ms,
plot='')
fit()
count = 1 if (raises == BreakIteration) else (self.npeaks - 1)
assert m1.counter.get() == count
if array:
assert m2.counter.get() == count - 1
def test_plot(self, measurement, monkeypatch):
if type(measurement.fitter).__name__ == 'PeakFind':
skip()
return
monkeypatch.setattr(config, 'store', 'CSVStore')
measurement.plot_format = 'png'
store = measurement()
frame = store['/Fit']
assert list(frame['plot'].values) == [1]
assert os.path.isfile(store.filename('/plot_1', '.png'))
class BasicElliprTest(AllDtypeTest, BaseCasesTest):
@mark.parametrize('ours, theirs, nargs', ELLIPR_FUNCMAP)
@given(*4 * (_complex_number, ))
def test_values(self, ours, theirs, nargs, x, y, z, p):
args = (x, y, z, p)[:nargs]
assert nice_and_close(ours(*args), theirs(*args))
# From Carlson (1995) except where stated otherwise
test_case = BaseCasesTest.parametrize({
elliprc: (
((0, 1 / 4), pi),
((9 / 4, 2), log(2)),
((0, 1j), (1 - 1j) * 1.1107207345396),
((-1j, 1j), 1.2260849569072 - 0.34471136988768j),
((0.25, -2), log(2) / 3),
((1j, -1), 0.77778596920447 + 0.19832484993429j),
),
elliprd: (
((0, 2, 1), 3 * gamma(3 / 4)**2 /
(2 * pi)**0.5), # https://dlmf.nist.gov/19.20.E22
((2, 3, 4), 0.16510527294261),
((1j, -1j, 2), 0.65933854154220),
((0, 1j, -1j), 1.2708196271910 + 2.7811120159521j),
((0, 1j - 1, 1j), -1.8577235439239 - 0.96193450888839j),
((-2 - 1j, -1j, -1 + 1j), 1.8249027393704 - 1.2218475784827j),
),
elliprf: (
((1, 2, 0), gamma(1 / 4)**2 / 4 /
(2 * pi)**0.5), # https://dlmf.nist.gov/19.20.E2
((0.5, 1, 0), 1.8540746773014),
((1j, -1j, 0), 1.8540746773014),
((1j - 1, 1j, 0), 0.79612586584234 - 1.2138566698365j),
((2, 3, 4), 0.58408284167715),
((1j, -1j, 2), 1.0441445654064),
((1j - 1, 1j, 1 - 1j), 0.93912050218619 - 0.53296252018635j),
),
elliprg: (
((0, 16, 16), pi),
((2, 3, 4), 1.7255030280692),
((0, 1j, -1j), 0.42360654239699),
((1j - 1, 1j, 0), 0.44660591677018 + 0.70768352357515j),
((-1j, 1j - 1, 1j), 0.36023392184473 + 0.40348623401722j),
((0, 0.0796, 4), 1.0284758090288),
# mpmath:
((0, 0, 0), 0),
((0, 0, 16), 2),
((1, 4, 0), 1.2110560275684595248036),
((1, 1j, -1 + 1j),
0.64139146875812627545 + 0.58085463774808290907j),
),
elliprj: (
((0, 1, 2, 3), 0.77688623778582),
((2, 3, 4, 5), 0.14297579667157),
((2, 3, 4, -1 + 1j), 0.13613945827771 - 0.38207561624427j),
((1j, -1j, 0, 2), 1.6490011662711),
((-1 + 1j, -1 - 1j, 1, 2), 0.94148358841220),
((1j, -1j, 0, 1 - 1j), 1.8260115229009 + 1.2290661908643j),
((-1 + 1j, -1 - 1j, 1, -3 + 1j),
-0.61127970812028 - 1.0684038390007j),
((-1 + 1j, -2 - 1j, -1j, -1 + 1j),
1.8249027393704 - 1.2218475784827j),
# computed using mpmath; see comment in C95
((2, 3, 4, -0.5), 0.24723819703052 - 0.7509842836890j),
((2, 3, 4, -5), -0.12711230042964 - 0.2099064885453j),
)
})
# from mpmath; Carlson's algorithm is not guaranteed, so mpmath integrates numerically
# for now we can't handle these cases although for all but the first two cases
# the algorith is correct
cases_elliprj_fail = (
((-1 - 0.5j, -10 - 6j, -10 - 3j, -5 + 10j),
0.128470516743927699 + 0.102175950778504625j), # fails
((1.987, 4.463 - 1.614j, 0, -3.965),
-0.341575118513811305 - 0.394703757004268486j), # fails
((0.3068, -4.037 + 0.632j, 1.654, -0.9609),
-1.14735199581485639 - 0.134450158867472264j),
((0.3068, -4.037 - 0.632j, 1.654, -0.9609),
1.758765901861727 - 0.161002343366626892j),
((0.3068, -4.037 + 0.0632j, 1.654, -0.9609),
-1.17157627949475577 - 0.069182614173988811j),
((0.3068, -4.037 + 0.00632j, 1.654, -0.9609),
-1.17337595670549633 - 0.0623069224526925j),
((0.3068, -4.037 - 0.0632j, 1.654, -0.9609),
1.77940452391261626 + 0.0388711305592447234j),
((0.3068, -4.037 - 0.00632j, 1.654, -0.9609),
1.77806722756403055 + 0.0592749824572262329j))
def test_elliprj_fail(self):
assert elliprj(*torch.tensor(next(zip(
*self.cases_elliprj_fail))).T).real.isnan().all()
@given(*3 * _complex_numbers)
def test_definitions(self, x, y, z):
assert close(elliprc(x, y), elliprf(x, y, y))
assert close(elliprd(x, y, z), elliprj(x, y, z, z))
@mark.parametrize(
'func, nsym, nadd',
((elliprf, 3, 0),
param(elliprg,
3,
0,
marks=mark.xfail(
reason='implementation not symmetric, fails for floats')),
(elliprd, 2, 1), (elliprj, 3, 1)))
def test_symmetry(self, func, nsym, nadd):
@given(st.tuples(*(nsym + nadd) * _complex_numbers))
def _test(args: torch.Tensor):
assert all(
close(f1, f2) for f1, f2 in combinations((
func(*arg, *args[nsym:])
for arg in permutations(args[:nsym])), 2))
_test()
(
"ixmp://example/m/s#42",
dict(name="example"),
dict(model="m", scenario="s", version=42),
),
("ixmp://example/m/s", dict(name="example"), m_s),
("ixmp://local/m/s", dict(name="local"), m_s),
(
"ixmp://local/m/s/foo/bar",
dict(name="local"),
dict(model="m", scenario="s/foo/bar"),
),
("m/s#42", dict(), dict(model="m", scenario="s", version=42)),
# Invalid values
# Wrong scheme
param("foo://example/m/s", None, None, marks=mark.xfail(raises=ValueError)),
# No Scenario name
param("ixmp://example/m", None, None, marks=mark.xfail(raises=ValueError)),
# Version not an integer
param(
"ixmp://example/m#notaversion", None, None, marks=mark.xfail(raises=ValueError)
),
# Query string not supported
param(
"ixmp://example/m/s?querystring",
None,
None,
marks=mark.xfail(raises=ValueError),
),
]
assert np.shape(K.RA) == np.shape(times)
assert np.shape(K.Dec) == np.shape(times)
assert np.shape(K.times) == np.shape(times)
# Test that K.RA, K.Dec, K.times and K.obs_code have expected values.
expect_RADec = _radec_interp(times, _radec_from_file(object_name, obs_code))
assert np.all(np.isclose(K.RA, expect_RADec[0], atol=0.00000001, rtol=0))
assert np.all(np.isclose(K.Dec, expect_RADec[1], atol=0.00000001, rtol=0))
assert np.all(K.times == times)
assert K.obs_code == obs_code
print('\t Completed test_instantiate_with_object_name.')
names_of_variables = ('orbit', 'obs_code', 'times')
values_for_each_test = [
pytest.param(aeiOoME_sedna, '568', all_times,
marks=mark.xfail(reason='Functionality not implemented.')),
]
@pytest.mark.parametrize(names_of_variables, values_for_each_test)
def test__get_orbit_RADEC(orbit, obs_code, times):
'''
Test the private method for getting RA/Dec from an orbit.
'''
K = known.Known()
K._get_orbit_RADEC(obs_code=obs_code, times=times, orbit=orbit)
# Test that K.RA, K.Dec exist and have expected type.
assert isinstance(K.RA, np.ndarray)
assert isinstance(K.Dec, np.ndarray)
# Test that K.RA, K.Dec have expected shape.
assert np.shape(K.RA) == np.shape(times)
assert np.shape(K.Dec) == np.shape(times)
# Test that K.RA, K.Dec have expected values.
def xfail_known_issues(request, known_issue: str):
if known_issue:
request.applymarker(mark.xfail(reason=known_issue))
class TestNormalize(MeasurementTests):
@fixture(params=[(False, False), (True, False), (False, True),
mark.xfail((True, True))],
ids=['X', '_X', 'X_', '_X_'])
def source(self, request):
# one to three index levels with the segment level in different positions
prefix, suffix = request.param
levels = []
if prefix:
levels.append(('x', list(range(2))))
levels.append(('segment', list(range(10))))
if suffix:
levels.append(('y', list(range(3))))
names, levels = zip(*levels)
index = pd.MultiIndex.from_product(levels, names=names)
segment_labels = index.get_level_values('segment').values
data = np.concatenate(([-1, 1], np.linspace(-1, 1, 8)))[segment_labels]
frame = pd.DataFrame({'data': data}, index)
return Constant(frame)
@fixture
def measurement(self, source):
return NormalizeAWG(source)
@mark.parametrize('g_value,e_value', [(-1, 1), (0, 1)],
ids=['(-1, 1)', '(0, 1)'])
def test_return(self, source, g_value, e_value):
reference = np.linspace(g_value, e_value, 8)
measurement = NormalizeAWG(source, g_value=g_value, e_value=e_value)
series = measurement(output_data=True)['data']
if series.index.nlevels > 1:
series = series.unstack('segment')
assert np.all(reference == series.values)
def test_drop_cal(self, source):
reference = np.concatenate(([-1, 1], np.linspace(-1, 1, 8)))
measurement = NormalizeAWG(source, drop_cal=False)
series = measurement(output_data=True)['data']
if series.index.nlevels > 1:
series = series.unstack('segment')
assert np.all(reference == series.values)
def test_source_attr(self, source):
measurement = NormalizeAWG()
measurement.source = source
assert measurement.coordinates == source.coordinates
assert measurement.values == source.values
measurement()
@mark.parametrize('chpair', [0, 1])
def test_chpair(self, chpair):
measurement = NormalizeAWG(chpair=chpair)
seq = measurement.template_func()
assert len(seq.sequences[2 * chpair].segments) == 2
def test_gepulses_list(self):
measurement = NormalizeAWG(g_pulses=[pulsegen.pix],
e_pulses=[pulsegen.piy],
chpair=0)
seq = measurement.template_func()
seq.sample()
# pix is in I, and piy in Q
sseqs = seq.sampled_sequences
assert np.allclose(sseqs[0].waveforms[0], -sseqs[1].waveforms[1])
assert np.allclose(sseqs[1].waveforms[0], sseqs[0].waveforms[1])
def test_gepulses_dict(self):
measurement = NormalizeAWG(g_pulses={
0: [pulsegen.pix],
1: [pulsegen.piy]
},
e_pulses={
0: [pulsegen.piy],
1: [pulsegen.pix]
})
seq = measurement.template_func()
seq.sample()
sseqs = seq.sampled_sequences
assert np.allclose(sseqs[0].waveforms[0], -sseqs[1].waveforms[1])
assert np.allclose(sseqs[1].waveforms[0], sseqs[0].waveforms[1])
@mark.parametrize("factory", [
TextMessageFactory(),
LocationMessageFactory(),
LiveLocationMessageFactory(),
ContactMessageFactory(),
StickerMessageFactory(),
DocumentMessageFactory(),
PhotoMessageFactory(),
VoiceMessageFactory(),
AudioMessageFactory(),
VideoMessageFactory(),
VideoNoteMessageFactory(),
AnimationMessageFactory(),
param(DiceMessageFactory(),
marks=mark.xfail(
reason="Telethon has not uploaded the feature to PyPI."))
],
ids=str)
async def test_master_message(helper, client, bot_group, slave, channel,
factory: MessageFactory):
chat = slave.chat_without_alias
with link_chats(channel, (chat, ), bot_group):
# Send message
tg_msg = await factory.send_message(client, bot_group)
efb_msg = slave.messages.get(timeout=5)
assert efb_msg.chat == chat
assert isinstance(efb_msg.author, SelfChatMember)
assert efb_msg.deliver_to is slave
assert not efb_msg.edit
assert not efb_msg.edit_media
class TestApply(MeasurementTests):
@fixture(params=[
'scalar', 'vector', 'matrix', 'matrix_complex', '3darray',
'matrix_transpose', '3darray_transpose'
])
def frame(self, request):
return frame_factory(request.param)
def function(self, arg0, arg1):
return arg0 + arg1
def arg_factory(self, arg, type_):
if type_ == 'measurement':
return Constant(arg)
elif type_ == 'parameter':
return Parameter('arg', value=arg)
elif type_ == 'const':
return arg
def measurement_factory(self,
arg0,
arg1,
type0='measurement',
type1='measurement',
**kwargs):
return Apply(self.function, self.arg_factory(arg0, type0),
self.arg_factory(arg1, type1), **kwargs)
@fixture
def measurement(self, frame):
self.arg0 = frame
self.arg1 = frame
return self.measurement_factory(frame, frame)
@mark.parametrize('type0,type1', [('measurement', 'parameter'),
('measurement', 'const'),
('parameter', 'measurement'),
('const', 'measurement'),
('const', 'const')])
def test_type(self, type0, type1):
arg0 = frame_factory('vector')
arg1 = frame_factory('vector')
m = self.measurement_factory(arg0, arg1, type0, type1)
frame = m(output_data=True)
function_values = self.function(arg0.values, arg1.values)
assert np.all(frame.values == function_values)
def test_scalar(self):
arg0 = frame_factory('vector')
arg1 = 2.
m = self.measurement_factory(arg0, arg1, 'measurement', 'const')
frame = m(output_data=True)
function_values = self.function(arg0.values, arg1)
assert np.all(frame.values == function_values)
@mark.parametrize('shape', ['scalar', 'vector', 'matrix', '3darray'])
def test_same(self, shape):
arg0 = frame_factory(shape)
arg1 = frame_factory(shape)
frame = self.measurement_factory(arg0, arg1)(output_data=True)
function_values = self.function(arg0.values, arg1.values)
assert np.all(frame.values == function_values)
@mark.xfail
@mark.parametrize('shape', ['matrix', '3darray'])
def test_transpose(self, shape):
arg0 = frame_factory(shape)
arg1 = frame_factory(shape + '_transpose')
frame = self.measurement_factory(arg0, arg1)(output_data=True)
return # broken in pd, remove on XPASS
function_values = self.function(arg0.values, arg0.values)
assert np.all(frame.values == function_values)
@mark.parametrize('shape0,shape1', [('vector', 'scalar'),
('matrix', 'scalar'),
('3darray', 'scalar'),
('matrix', 'vector'),
('matrix_transpose', 'vector'),
('3darray', 'vector'),
('3darray_transpose', 'vector'),
('matrix', 'matrix_singleton'),
mark.xfail(('3darray', 'matrix'))])
def test_broadcast(self, shape0, shape1):
arg0 = frame_factory(shape0)
arg1 = frame_factory(shape1)
frame = self.measurement_factory(arg0, arg1)(output_data=True)
if arg0.index.nlevels == 1:
assert frame.index.shape == arg0.index.shape
else:
assert frame.index.levshape == arg0.index.levshape
assert not np.any(np.isnan(frame.values)), 'Result has NaNs'
param(
{
'name': 'Czech Republic',
'code': 'CZ',
'timezone': 'Europe/Prague',
},
id='official_name',
),
param(
{
'name': 'United States',
'code': 'CZ',
'timezone': 'Europe/Prague',
},
id='ambiguous',
marks=mark.xfail(
raises=ValueError,
reason='country is ambiguous',
),
)
])
def test_parse_country_strict(data):
expected_keys = {
'country',
'timezone',
}
parsed = parsers.parse_country(data, strict=True)
assert not expected_keys.symmetric_difference(parsed.keys())
assert isinstance(parsed['country'], pycountry.db.Data)
assert isinstance(parsed['timezone'], datetime.tzinfo)
m_s = dict(model='m', scenario='s')
URLS = [
('ixmp://example/m/s', dict(name='example'), m_s),
('ixmp://example/m/s#42', dict(name='example'),
dict(model='m', scenario='s', version=42)),
('ixmp://example/m/s', dict(name='example'), m_s),
('ixmp://local/m/s', dict(name='local'), m_s),
('ixmp://local/m/s/foo/bar', dict(name='local'),
dict(model='m', scenario='s/foo/bar')),
('m/s#42', dict(), dict(model='m', scenario='s', version=42)),
# Invalid values
# Wrong scheme
param('foo://example/m/s', None, None,
marks=mark.xfail(raises=ValueError)),
# No Scenario name
param('ixmp://example/m', None, None, marks=mark.xfail(raises=ValueError)),
# Version not an integer
param('ixmp://example/m#notaversion',
None,
None,
marks=mark.xfail(raises=ValueError)),
# Query string not supported
param('ixmp://example/m/s?querystring',
None,
None,
marks=mark.xfail(raises=ValueError)),
]
@fixture(params=[True, False], scope='module')
def standardize(request):
return request.param
@fixture(params=['subset1', None, 'phenotype: group1', '~subset1', 'ids'],
scope='module')
def sample_subset(request, samples):
if request.param == 'ids':
return samples[:10]
else:
return request.param
@fixture(params=[None, 'all', 'gene_category: A', 'W',
mark.xfail('asdf')],
ids=[
'none', 'all_features', 'categorical_gene_category',
'boolean_gene_category', 'nonexistent_gene_category'
],
scope='module')
def feature_subset(request):
return request.param
@fixture(scope='module')
def splicing(splicing_data):
from flotilla.data_model.splicing import SplicingData
return SplicingData(splicing_data)
assert False
@mark.parametrize('reader_kwargs,compress_kwargs', [
(dict(add_references=False), dict()),
(dict(add_references=False), dict(verify=True)),
(dict(add_references=False), dict(verify=False)),
(dict(add_references=False), dict(verify=True, single_analytic=True)),
(dict(add_references=False), dict(verify=False, single_analytic=True)),
(dict(add_references=False), dict(verify=True, single_analytic=False)),
(dict(add_references=False), dict(verify=False, single_analytic=False)),
(dict(add_references=False), dict(single_analytic=False)),
(dict(add_references=False), dict(single_analytic=True)),
(dict(add_references=True), dict()),
mark.xfail(
(dict(add_references=True), dict(verify=True)),
strict=True,
),
(dict(add_references=True), dict(verify=False)),
mark.xfail(
(dict(add_references=True), dict(verify=True, single_analytic=True)),
strict=True,
),
(dict(add_references=True), dict(verify=False, single_analytic=True)),
mark.xfail(
(dict(add_references=True), dict(verify=True, single_analytic=False)),
strict=True,
),
(dict(add_references=True), dict(verify=False, single_analytic=False)),
(dict(add_references=True), dict(single_analytic=False)),
(dict(add_references=True), dict(single_analytic=True)),
])
(10,14,15,1),
(10,15,15,1)
)
voxels = [Voxel(x,y,z, E) for (x,y,z,E) in voxel_spec]
tracks = make_track_graphs(voxels, np.array([1,1,1]), contiguity=1.85)
assert len(tracks) == 1
track_length = length(tracks[0])
expected_length = 8 + np.sqrt(2)
assert track_length == approx(expected_length)
@parametrize('contiguity, expected_length',
(mark.xfail((1.2, 4), reason='contiguity is broken'),
(1.5, 2 * sqrt(2))))
def test_length_around_bend(contiguity, expected_length):
# Make sure that we calculate the length along the track rather
# that the shortcut
voxel_spec = ((0,0,0, 1),
(1,0,0, 1),
(1,1,0, 1),
(1,2,0, 1),
(0,2,0, 1))
voxels = list(starmap(Voxel, voxel_spec))
tracks = make_track_graphs(voxels, np.array([1,1,1]), contiguity=contiguity)
assert len(tracks) == 1
track_length = length(tracks[0])
assert track_length == approx(expected_length)
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""DataFork, Junior Data Engineer, Question 2."""
__author__ = "Stanislav D. Kudriavtsev"
from pytest import mark, param
from question2 import solve
@mark.parametrize(
"shops, visitors, ranges, ans",
[(6, 5, [(3, 5), (2, 3), (4, 6), (1, 6), (5, 6)], {3, 4, 5}),
(1, 1, [(1, 1)], {1}),
param(1, 2, [(1, 1), (1, 2)], 1, marks=mark.xfail(reason='range(1, 2)'))])
def test_case1(shops, visitors, ranges, ans):
"""
Test case from question2.py module docstring.
Parameters
----------
shops : int.
visitors : int.
ranges : List
the range of visited shops (inclusive).
ans : set
expected answer.
Returns
-------
first = sp_out.split("\n")[0]
return tuple(int(x) for x in re.match(DCMTK_VER_RE, first).groups())
DCMTK_VERSION = get_dcmtk_version()
dcmtk_base_port = 62760
dcmtk_base_name = "DCMTKAE"
has_dcmtk = mark.skipif(DCMTK_VERSION is None,
reason="can't find DCMTK command 'dcmqrscp'")
dcmtk_priv_sop_retr_xfail = mark.xfail(
DCMTK_VERSION is None or DCMTK_VERSION < DCMTK_PRIV_RETR_VERS,
reason="dcmqrscp version doesn't support retrieving private "
"SOPClasses",
)
dcmtk_priv_sop_send_xfail = mark.xfail(
DCMTK_VERSION is None or DCMTK_VERSION < DCMTK_PRIV_SEND_VERS,
reason="dcmqrscp version doesn't support sending private "
"SOPClasses",
)
dcmtk_config_tmpl = """\
NetworkTCPPort = {dcmtk_node.port}
MaxPDUSize = 16384
MaxAssociations = 16
HostTable BEGIN
m_s = dict(model='m', scenario='s')
URLS = [
('ixmp://example/m/s', dict(name='example'), m_s),
('ixmp://example/m/s#42', dict(name='example'),
dict(model='m', scenario='s', version=42)),
('ixmp://example/m/s', dict(name='example'), m_s),
('ixmp://local/m/s', dict(name='local'), m_s),
('ixmp://local/m/s/foo/bar', dict(name='local'),
dict(model='m', scenario='s/foo/bar')),
('m/s#42', dict(), dict(model='m', scenario='s', version=42)),
# Invalid values
# Wrong scheme
param('foo://example/m/s', None, None,
marks=mark.xfail(raises=ValueError)),
# No Scenario name
param('ixmp://example/m', None, None,
marks=mark.xfail(raises=ValueError)),
# Version not an integer
param('ixmp://example/m#notaversion', None, None,
marks=mark.xfail(raises=ValueError)),
# Query string not supported
param('ixmp://example/m/s?querystring', None, None,
marks=mark.xfail(raises=ValueError)),
]
@pytest.mark.parametrize('url, p, s', URLS)
def test_parse_url(url, p, s):
platform_info, scenario_info = utils.parse_url(url)
["0x12 345 678 901 234 567 890", 0x12345678901234567890],
]
dec = [
["1234", 1234],
["12345678901234567890", 12345678901234567890],
["1 234", 1234],
["12 345 678 901 234 567 890", 12345678901234567890],
]
idn = [
"abc",
"ab0",
"ab_",
"a0_",
mark.xfail("0bc"),
mark.xfail("!ab"),
mark.xfail("_ab"),
]
exp = [
["1", 1],
["a", "a"],
["1 @ b", [1, "@", "b"]],
["1 * b", [1, "*", "b"]],
["1 / b", [1, "/", "b"]],
["1 + b", [1, "+", "b"]],
["1 - b", [1, "-", "b"]],
["1 @ b @ 3", [1, "@", ["b", "@", 3]]],
["1 @ b * 3", [[1, "@", "b"], "*", 3]],
["1 @ b / 3", [[1, "@", "b"], "/", 3]],
def standardize(request):
return request.param
@fixture(
params=['subset1', None, 'phenotype: group1', '~subset1', 'ids'],
scope='module')
def sample_subset(request, samples):
if request.param == 'ids':
return samples[:10]
else:
return request.param
@fixture(
params=[None, 'all', 'gene_category: A', 'W', mark.xfail('asdf')],
ids=['none', 'all_features', 'categorical_gene_category',
'boolean_gene_category', 'nonexistent_gene_category'],
scope='module')
def feature_subset(request):
return request.param
@fixture(scope='module')
def splicing(splicing_data):
from flotilla.data_model.splicing import SplicingData
return SplicingData(splicing_data)
@fixture(scope='module')
def gene_ontology_data_path(data_dir):
from operator import itemgetter, attrgetter
from functools import reduce
from argparse import Namespace
from copy import copy
import itertools as it
from pytest import mark, raises
xfail = mark.xfail
TODO = mark.xfail(reason='TODO')
GETITEM_FUNDAMENTALLY_BROKEN = xfail(
reason="__getitem__ can't distinguish x[a,b] from x[(a,b)]")
parametrize = mark.parametrize
from hypothesis import given
from hypothesis import assume
from hypothesis.strategies import tuples
from hypothesis.strategies import integers
from hypothesis.strategies import none
from hypothesis.strategies import one_of, sampled_from
from testhelpers import *
###################################################################
def test_map():
from liquidata import pipe
data = list(range(10))
f, = symbolic_functions('f')
assert pipe(f)(data) == list(map(f, data))
x = f(*args)
y = wrap(f)(*args)
assert x - y < delta and type(x) == type(y)
def make_exc_test(f, args, py_exc, stella_exc):
with raises(py_exc):
x = f(*args) # noqa
with raises(stella_exc):
y = wrap(f)(*args) # noqa
assert True
unimplemented = mark.xfail(reason="Unimplemented", run=False)
bench = mark.bench
@pytest.fixture
def bench_opt(request):
opt = request.config.getoption("--bench")
if opt in ('l', 'long'):
return 2
elif opt in ('s', 'short'):
return 1
else:
return 0
@pytest.fixture
async def finalize_message(self, tg_msg: Message, efb_msg: EFBMessage):
if efb_msg.file and not efb_msg.file.closed:
efb_msg.file.close()
# endregion Message factory classes
@mark.parametrize("factory", [
TextMessageFactory(),
LocationMessageFactory(),
LiveLocationMessageFactory(),
ContactMessageFactory(),
StickerMessageFactory(),
param(DocumentMessageFactory(),
marks=mark.xfail(reason="PTB does not support Bot API 4.5")),
param(PhotoMessageFactory(),
marks=mark.xfail(reason="PTB does not support Bot API 4.5")),
param(VoiceMessageFactory(),
marks=mark.xfail(reason="PTB does not support Bot API 4.5")),
param(AudioMessageFactory(),
marks=mark.xfail(reason="PTB does not support Bot API 4.5")),
param(VideoMessageFactory(),
marks=mark.xfail(reason="PTB does not support Bot API 4.5")),
param(VideoNoteMessageFactory(),
marks=mark.xfail(reason="PTB does not support Bot API 4.5")),
param(AnimationMessageFactory(),
marks=mark.xfail(reason="PTB does not support Bot API 4.5"))
],
ids=str)
async def test_master_message(helper, client, bot_group, slave, channel,
@mark.parametrize("tst,exp", [
["field 2 @ 255 - 19;", f"field {LIMIT};"],
])
def test_limit_condenser(tst, exp):
t = {"limit": ast.FLD.parseString(tst).asList()[0]}
e = {"limit": ast.FLD.parseString(exp).asList()[0]}
LimitCondenser()(t)
assert t == e
@mark.parametrize("tst,exp", [
["a = 5;", "a = 5;"],
["a = 5 + 5;", "a = 10;"],
["a = 5; b = a + 5;", "a = 5; b = 10;"],
[f"c = {LIMIT-1} + 3;", "c = 2;"],
mark.xfail(["a = b;", "a = b;"]),
mark.xfail(["b = a + 5;", "b = 10;"]),
])
def test_constants_condenser(tst, exp):
t = {"limit": LIMIT, "items": ast.BDY.parseString(tst).asList()[0]}
e = {"limit": LIMIT, "items": ast.BDY.parseString(exp).asList()[0]}
ConstantCondenser()(t)
assert t == e
@mark.parametrize("tst,exp", [
[
"a = 5; foo(x, y)(z) { z = x + y; }",
"a = 5; foo(x, y)(z) { z = x + y; }"
],
[
x = f(*args)
y = wrap(f)(*args)
assert x - y < delta and type(x) == type(y)
def make_exc_test(f, args, py_exc, stella_exc):
with raises(py_exc):
x = f(*args) # noqa
with raises(stella_exc):
y = wrap(f)(*args) # noqa
assert True
unimplemented = mark.xfail(reason="Unimplemented", run=False)
bench = mark.bench
@pytest.fixture
def bench_opt(request):
opt = request.config.getoption("--bench")
if opt in ('l', 'long'):
return 2
elif opt in ('s', 'short'):
return 1
else:
return 0
@pytest.fixture
