detectors/slsDetectorPackage
25
0
Fork 0
mirror of https://github.com/slsdetectorgroup/slsDetectorPackage.git synced 2025-04-20 02:40:03 +02:00
Code Issues Actions Packages Releases Activity

added counters to python

Browse Source
This commit is contained in:
Erik Frojdh 2020-01-15 17:26:07 +01:00
parent de53747ddd
commit 39ec29c0e6
6 changed files with 521 additions and 453 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
python/scripts/basic.py
View File

@ -8,7 +8,7 @@ from sls_detector import Detector, Eiger, Jungfrau, DetectorDacs, Dac, Ctb
from sls_detector import dacIndex from sls_detector import dacIndex
# d = Detector() d = Detector()
# e = Eiger() # e = Eiger()
# c = Ctb() # c = Ctb()
j = Jungfrau() j = Jungfrau()

20
python/sls_detector/detector.py
View File

@ -5,7 +5,7 @@ runStatus = slsDetectorDefs.runStatus
speedLevel = slsDetectorDefs.speedLevel speedLevel = slsDetectorDefs.speedLevel
dacIndex = slsDetectorDefs.dacIndex dacIndex = slsDetectorDefs.dacIndex
from .utils import element_if_equal, all_equal from .utils import element_if_equal, all_equal, get_set_bits, list_to_bitmask
from .utils import Geometry, to_geo from .utils import Geometry, to_geo
from .registers import Register, Adc_register from .registers import Register, Adc_register
import datetime as dt import datetime as dt
@ -752,6 +752,24 @@ class Detector(CppDetectorApi):
self.setStoreInRamMode(value) self.setStoreInRamMode(value)
"""
Mythen3 specific
"""
@property
def counters(self):
mask = self.getCounterMask()
mask = element_if_equal(mask)
if type(mask) == int:
return get_set_bits(mask)
else:
return [get_set_bits(m) for m in mask]
@counters.setter
def counters(self, values):
self.setCounterMask(list_to_bitmask(values))
""" """
CTB stuff CTB stuff
""" """

17
python/sls_detector/utils.py
View File

@ -8,6 +8,23 @@ import functools
Geometry = namedtuple('Geometry', ['x', 'y']) Geometry = namedtuple('Geometry', ['x', 'y'])
def get_set_bits(mask):
"""
Return a list of the set bits in a python integer
"""
return [i for i in range(mask.bit_length()) if (mask>>i)&1]
def list_to_bitmask(values):
"""
Convert a list of integers to a bitmask with set bits
where the list indicates
"""
mask = int(0)
values = list(set(values)) #Remove duplicates
for v in values:
mask += 1 << v
return mask
def to_geo(value): def to_geo(value):
if isinstance(value, _sls_detector.xy): if isinstance(value, _sls_detector.xy):
return Geometry(x = value.x, y = value.y) return Geometry(x = value.x, y = value.y)

4
python/src/detector.cpp
View File

@ -441,6 +441,10 @@ void init_det(py::module &m) {
.def("setBurstMode", &Detector::setBurstMode, py::arg(), .def("setBurstMode", &Detector::setBurstMode, py::arg(),
py::arg() = Positions{}) py::arg() = Positions{})
.def("getBurstMode", &Detector::getBurstMode, py::arg() = Positions{}) .def("getBurstMode", &Detector::getBurstMode, py::arg() = Positions{})
.def("getCounterMask", &Detector::getCounterMask,
py::arg() = Positions{})
.def("setCounterMask", &Detector::setCounterMask, py::arg(),
py::arg() = Positions{})
.def("getNumberOfAnalogSamples", &Detector::getNumberOfAnalogSamples, .def("getNumberOfAnalogSamples", &Detector::getNumberOfAnalogSamples,
py::arg() = Positions{}) py::arg() = Positions{})
.def("setNumberOfAnalogSamples", &Detector::setNumberOfAnalogSamples, .def("setNumberOfAnalogSamples", &Detector::setNumberOfAnalogSamples,

911
python/unit-tests/detector_test.py
View File

@ -1,8 +1,13 @@
#!/usr/bin/env python3 #!/usr/bin/env python3
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
""" """
Testing parameters and methods of the Detector class using mocks Testing the Detector python class by mocking calls.
Should only be used when there is functionality in
the detector.py file.
An example is converting a mask to a list of set bits.
""" """
from unittest.mock import Mock from unittest.mock import Mock
import pytest import pytest
from pytest_mock import mocker from pytest_mock import mocker
@ -13,459 +18,471 @@ sys.path.append('/home/l_frojdh/slsdetectorgrup/sls_detector')
import _sls_detector import _sls_detector
from sls_detector.errors import DetectorValueError, DetectorError from sls_detector.errors import DetectorValueError, DetectorError
from sls_detector.utils import all_equal, element_if_equal from sls_detector.utils import all_equal, element_if_equal
@pytest.fixture @pytest.fixture
def d(): def d():
from sls_detector import Detector from sls_detector import Detector
return Detector() return Detector()
def test_length(d, mocker):
m = mocker.patch('sls_detector.Detector.size')
m.return_value = 5
assert(len(d) == 5)
def test_length_zero(d): def test_counters_single(d, mocker):
assert len(d) == 0 m = mocker.patch('sls_detector.Detector.getCounterMask')
m.return_value = [7]
assert(d.counters == [0,1,2])
def test_acq_call(d, mocker): def test_counters_multi(d, mocker):
m = mocker.patch('_sls_detector.DetectorApi.acq') m = mocker.patch('sls_detector.Detector.getCounterMask')
d.acq() m.return_value = [7, 9]
m.assert_called_once_with() assert(d.counters == [[0,1,2],[0,3]])
def test_set_counters_single(d, mocker):
m = mocker.patch('sls_detector.Detector.setCounterMask')
def test_busy_call(d, mocker): d.counters = [0,2]
m = mocker.patch('_sls_detector.DetectorApi.getAcquiringFlag') m.assert_called_once_with(5)
m.return_value = False
assert d.busy == False
def test_set_busy(d): # def test_busy_call(d, mocker):
d.busy = True # m = mocker.patch('_sls_detector.DetectorApi.getAcquiringFlag')
assert d.busy == True # m.return_value = False
assert d._api.getAcquiringFlag() == True # assert d.busy == False
d.busy = False
assert d.busy == False # def test_set_busy(d):
assert d._api.getAcquiringFlag() == False # d.busy = True
# assert d.busy == True
def test_error_mask(d): # assert d._api.getAcquiringFlag() == True
d._api.setErrorMask(1) # d.busy = False
assert d.error_mask == 1 # assert d.busy == False
d.clear_errors() # assert d._api.getAcquiringFlag() == False
def test_error_handling(d): # def test_error_mask(d):
with pytest.raises(DetectorError): # d._api.setErrorMask(1)
d._provoke_error() # assert d.error_mask == 1
# d.clear_errors()
def test_assign_to_detector_type(d):
with pytest.raises(AttributeError): # def test_error_handling(d):
d.detector_type = 'Eiger' # with pytest.raises(DetectorError):
# d._provoke_error()
def test_det_type(d, mocker):
m = mocker.patch('_sls_detector.DetectorApi.getDetectorType') # def test_assign_to_detector_type(d):
m.return_value = 'Eiger' # with pytest.raises(AttributeError):
assert d.detector_type == 'Eiger' # d.detector_type = 'Eiger'
# def test_det_type(d, mocker):
def test_get_exposure_time(d, mocker): # m = mocker.patch('_sls_detector.DetectorApi.getDetectorType')
m = mocker.patch('_sls_detector.DetectorApi.getExposureTime') # m.return_value = 'Eiger'
m.return_value = 100000000 # assert d.detector_type == 'Eiger'
assert d.exposure_time == 0.1
def test_set_exposure_time(d, mocker): # def test_get_exposure_time(d, mocker):
m = mocker.patch('_sls_detector.DetectorApi.setExposureTime') # m = mocker.patch('_sls_detector.DetectorApi.getExposureTime')
d.exposure_time = 1.5 # m.return_value = 100000000
m.assert_called_once_with(1500000000) # assert d.exposure_time == 0.1
def test_set_exposure_time_less_than_zero(d, mocker): # def test_set_exposure_time(d, mocker):
mocker.patch('_sls_detector.DetectorApi.setExposureTime') # m = mocker.patch('_sls_detector.DetectorApi.setExposureTime')
with pytest.raises(DetectorValueError): # d.exposure_time = 1.5
d.exposure_time = -7 # m.assert_called_once_with(1500000000)
# def test_set_exposure_time_less_than_zero(d, mocker):
def test_get_file_index(d, mocker): # mocker.patch('_sls_detector.DetectorApi.setExposureTime')
m = mocker.patch('_sls_detector.DetectorApi.getFileIndex') # with pytest.raises(DetectorValueError):
m.return_value = 8 # d.exposure_time = -7
assert d.file_index == 8
def test_set_file_index(d, mocker): # def test_get_file_index(d, mocker):
m = mocker.patch('_sls_detector.DetectorApi.setFileIndex') # m = mocker.patch('_sls_detector.DetectorApi.getFileIndex')
d.file_index = 9 # m.return_value = 8
m.assert_called_with(9) # assert d.file_index == 8
# def test_set_file_index(d, mocker):
def file_index_with_no_detector(d): # m = mocker.patch('_sls_detector.DetectorApi.setFileIndex')
assert d.file_index == -100 # d.file_index = 9
# m.assert_called_with(9)
def dr_with_no_detector(d):
assert d.dynamic_range == -100
# def file_index_with_no_detector(d):
def test_set_file_index_raises_on_neg(d, mocker): # assert d.file_index == -100
mocker.patch('_sls_detector.DetectorApi.setFileIndex')
with pytest.raises(ValueError): # def dr_with_no_detector(d):
d.file_index = -9 # assert d.dynamic_range == -100
# def test_set_file_index_raises_on_neg(d, mocker):
def test_get_file_name(d, mocker): # mocker.patch('_sls_detector.DetectorApi.setFileIndex')
m = mocker.patch('_sls_detector.DetectorApi.getFileName') # with pytest.raises(ValueError):
d.file_name # d.file_index = -9
m.assert_called_once_with()
def test_set_file_name(d, mocker): # def test_get_file_name(d, mocker):
m = mocker.patch('_sls_detector.DetectorApi.setFileName') # m = mocker.patch('_sls_detector.DetectorApi.getFileName')
d.file_name = 'hej' # d.file_name
m.assert_called_once_with('hej') # m.assert_called_once_with()
def test_get_file_path(d, mocker): # def test_set_file_name(d, mocker):
m = mocker.patch('_sls_detector.DetectorApi.getFilePath') # m = mocker.patch('_sls_detector.DetectorApi.setFileName')
d.file_path # d.file_name = 'hej'
m.assert_called_once_with() # m.assert_called_once_with('hej')
def test_set_file_path_when_path_exists(d, mocker): # def test_get_file_path(d, mocker):
m = mocker.patch('_sls_detector.DetectorApi.setFilePath') # m = mocker.patch('_sls_detector.DetectorApi.getFilePath')
#To avoid raising an exception because path is not there # d.file_path
mock_os = mocker.patch('os.path.exists') # m.assert_called_once_with()
mock_os.return_value = True
d.file_path = '/path/to/something/' # def test_set_file_path_when_path_exists(d, mocker):
m.assert_called_once_with('/path/to/something/') # m = mocker.patch('_sls_detector.DetectorApi.setFilePath')
# #To avoid raising an exception because path is not there
def test_set_file_path_raises_when_not_exists(d, mocker): # mock_os = mocker.patch('os.path.exists')
mocker.patch('_sls_detector.DetectorApi.setFilePath') # mock_os.return_value = True
mock_os = mocker.patch('os.path.exists') # d.file_path = '/path/to/something/'
mock_os.return_value = False # m.assert_called_once_with('/path/to/something/')
with pytest.raises(FileNotFoundError):
d.file_path = '/path/to/something/' # def test_set_file_path_raises_when_not_exists(d, mocker):
# mocker.patch('_sls_detector.DetectorApi.setFilePath')
def test_get_file_write(d, mocker): # mock_os = mocker.patch('os.path.exists')
m = mocker.patch('_sls_detector.DetectorApi.getFileWrite') # mock_os.return_value = False
m.return_value = False # with pytest.raises(FileNotFoundError):
assert d.file_write == False # d.file_path = '/path/to/something/'
def test_set_file_write(d, mocker): # def test_get_file_write(d, mocker):
m = mocker.patch('_sls_detector.DetectorApi.setFileWrite') # m = mocker.patch('_sls_detector.DetectorApi.getFileWrite')
d.file_write = True # m.return_value = False
m.assert_called_once_with(True) # assert d.file_write == False
# def test_set_file_write(d, mocker):
def test_get_firmware_version(d, mocker): # m = mocker.patch('_sls_detector.DetectorApi.setFileWrite')
m = mocker.patch('_sls_detector.DetectorApi.getFirmwareVersion') # d.file_write = True
m.return_value = 20 # m.assert_called_once_with(True)
assert d.firmware_version == 20
def test_cannot_set_fw_version(d): # def test_get_firmware_version(d, mocker):
with pytest.raises(AttributeError): # m = mocker.patch('_sls_detector.DetectorApi.getFirmwareVersion')
d.firmware_version = 20 # m.return_value = 20
# assert d.firmware_version == 20
def test_get_high_voltage_call_signature(d, mocker):
m = mocker.patch('_sls_detector.DetectorApi.getDac') # def test_cannot_set_fw_version(d):
d.high_voltage # with pytest.raises(AttributeError):
m.assert_called_once_with('vhighvoltage', -1) # d.firmware_version = 20
def test_get_high_voltage(d, mocker): # def test_get_high_voltage_call_signature(d, mocker):
m = mocker.patch('_sls_detector.DetectorApi.getDac') # m = mocker.patch('_sls_detector.DetectorApi.getDac')
m.return_value = 80 # d.high_voltage
assert d.high_voltage == 80 # m.assert_called_once_with('vhighvoltage', -1)
#self._api.setDac('vhighvoltage', -1, voltage) # def test_get_high_voltage(d, mocker):
def test_set_high_voltage(d, mocker): # m = mocker.patch('_sls_detector.DetectorApi.getDac')
m = mocker.patch('_sls_detector.DetectorApi.setDac') # m.return_value = 80
d.high_voltage = 80 # assert d.high_voltage == 80
m.assert_called_once_with('vhighvoltage', -1, 80)
# #self._api.setDac('vhighvoltage', -1, voltage)
def test_decode_hostname_two_names(d, mocker): # def test_set_high_voltage(d, mocker):
m = mocker.patch('_sls_detector.DetectorApi.getHostname') # m = mocker.patch('_sls_detector.DetectorApi.setDac')
m.return_value = 'beb059+beb048+' # d.high_voltage = 80
assert d.hostname == ['beb059', 'beb048'] # m.assert_called_once_with('vhighvoltage', -1, 80)
def test_decode_hostname_four_names(d, mocker): # def test_decode_hostname_two_names(d, mocker):
m = mocker.patch('_sls_detector.DetectorApi.getHostname') # m = mocker.patch('_sls_detector.DetectorApi.getHostname')
m.return_value = 'beb059+beb048+beb120+beb153+' # m.return_value = 'beb059+beb048+'
assert d.hostname == ['beb059', 'beb048', 'beb120', 'beb153'] # assert d.hostname == ['beb059', 'beb048']
def test_decode_hostname_blank(d, mocker): # def test_decode_hostname_four_names(d, mocker):
m = mocker.patch('_sls_detector.DetectorApi.getHostname') # m = mocker.patch('_sls_detector.DetectorApi.getHostname')
m.return_value = '' # m.return_value = 'beb059+beb048+beb120+beb153+'
assert d.hostname == [] # assert d.hostname == ['beb059', 'beb048', 'beb120', 'beb153']
def test_get_image_size_gives_correct_size(d, mocker): # def test_decode_hostname_blank(d, mocker):
m = mocker.patch('_sls_detector.DetectorApi.getImageSize') # m = mocker.patch('_sls_detector.DetectorApi.getHostname')
m.return_value = (512,1024) # m.return_value = ''
im_size = d.image_size # assert d.hostname == []
assert im_size.rows == 512
assert im_size.cols == 1024 # def test_get_image_size_gives_correct_size(d, mocker):
# m = mocker.patch('_sls_detector.DetectorApi.getImageSize')
# m.return_value = (512,1024)
# im_size = d.image_size
def test_load_config(d, mocker): # assert im_size.rows == 512
m = mocker.patch('_sls_detector.DetectorApi.readConfigurationFile') # assert im_size.cols == 1024
#To avoid raising an exception because path is not there
mock_os = mocker.patch('os.path.isfile')
mock_os.return_value = True
d.load_config('/path/to/my/file.config') # def test_load_config(d, mocker):
m.assert_called_once_with('/path/to/my/file.config') # m = mocker.patch('_sls_detector.DetectorApi.readConfigurationFile')
# #To avoid raising an exception because path is not there
def test_load_config_raises_when_file_is_not_found(d, mocker): # mock_os = mocker.patch('os.path.isfile')
mocker.patch('_sls_detector.DetectorApi.readConfigurationFile') # mock_os.return_value = True
mock_os = mocker.patch('os.path.isfile') # d.load_config('/path/to/my/file.config')
mock_os.return_value = False # m.assert_called_once_with('/path/to/my/file.config')
with pytest.raises(FileNotFoundError):
d.load_config('/path/to/my/file.config') # def test_load_config_raises_when_file_is_not_found(d, mocker):
# mocker.patch('_sls_detector.DetectorApi.readConfigurationFile')
def test_load_parameters(d, mocker): # mock_os = mocker.patch('os.path.isfile')
m = mocker.patch('_sls_detector.DetectorApi.readParametersFile') # mock_os.return_value = False
#To avoid raising an exception because path is not there # with pytest.raises(FileNotFoundError):
mock_os = mocker.patch('os.path.isfile') # d.load_config('/path/to/my/file.config')
mock_os.return_value = True
d.load_parameters('/path/to/my/file.par') # def test_load_parameters(d, mocker):
m.assert_called_once_with('/path/to/my/file.par') # m = mocker.patch('_sls_detector.DetectorApi.readParametersFile')
# #To avoid raising an exception because path is not there
def test_load_parameters_raises_when_file_is_not_found(d, mocker): # mock_os = mocker.patch('os.path.isfile')
mocker.patch('_sls_detector.DetectorApi.readParametersFile') # mock_os.return_value = True
mock_os = mocker.patch('os.path.isfile') # d.load_parameters('/path/to/my/file.par')
mock_os.return_value = False # m.assert_called_once_with('/path/to/my/file.par')
with pytest.raises(FileNotFoundError):
d.load_parameters('/path/to/my/file.par') # def test_load_parameters_raises_when_file_is_not_found(d, mocker):
# mocker.patch('_sls_detector.DetectorApi.readParametersFile')
#getDetectorGeometry # mock_os = mocker.patch('os.path.isfile')
def test_get_module_geometry_gives_correct_size(d, mocker): # mock_os.return_value = False
m = mocker.patch('_sls_detector.DetectorApi.getDetectorGeometry') # with pytest.raises(FileNotFoundError):
m.return_value = (13,7) # d.load_parameters('/path/to/my/file.par')
g = d.module_geometry
assert g.vertical == 7 # #getDetectorGeometry
assert g.horizontal == 13 # def test_get_module_geometry_gives_correct_size(d, mocker):
# m = mocker.patch('_sls_detector.DetectorApi.getDetectorGeometry')
def test_get_module_geometry_access(d, mocker): # m.return_value = (13,7)
m = mocker.patch('_sls_detector.DetectorApi.getDetectorGeometry') # g = d.module_geometry
m.return_value = (12,3) # assert g.vertical == 7
assert d.module_geometry[0] == 12 # assert g.horizontal == 13
assert d.module_geometry[1] == 3
assert d.module_geometry.vertical == 3 # def test_get_module_geometry_access(d, mocker):
assert d.module_geometry.horizontal == 12 # m = mocker.patch('_sls_detector.DetectorApi.getDetectorGeometry')
# m.return_value = (12,3)
def test_module_geometry_without_detectors(d): # assert d.module_geometry[0] == 12
t = d.module_geometry # assert d.module_geometry[1] == 3
assert t.horizontal == 0 # assert d.module_geometry.vertical == 3
assert t.vertical == 0 # assert d.module_geometry.horizontal == 12
def test_get_n_frames(d, mocker): # def test_module_geometry_without_detectors(d):
m = mocker.patch('_sls_detector.DetectorApi.getNumberOfFrames') # t = d.module_geometry
m.return_value = 3 # assert t.horizontal == 0
assert d.n_frames == 3 # assert t.vertical == 0
def test_set_n_frames(d, mocker): # def test_get_n_frames(d, mocker):
m = mocker.patch('_sls_detector.DetectorApi.setNumberOfFrames') # m = mocker.patch('_sls_detector.DetectorApi.getNumberOfFrames')
d.n_frames = 9 # m.return_value = 3
m.assert_called_once_with(9) # assert d.n_frames == 3
def test_nframes_without_detector(d): # def test_set_n_frames(d, mocker):
assert d.n_frames == -100 # m = mocker.patch('_sls_detector.DetectorApi.setNumberOfFrames')
# d.n_frames = 9
def test_set_n_frames_raises_on_neg(d, mocker): # m.assert_called_once_with(9)
mocker.patch('_sls_detector.DetectorApi.setNumberOfFrames')
with pytest.raises(DetectorValueError): # def test_nframes_without_detector(d):
d.n_frames = -1 # assert d.n_frames == -100
def test_set_n_frames_raises_on_zero(d, mocker): # def test_set_n_frames_raises_on_neg(d, mocker):
mocker.patch('_sls_detector.DetectorApi.setNumberOfFrames') # mocker.patch('_sls_detector.DetectorApi.setNumberOfFrames')
with pytest.raises(DetectorValueError): # with pytest.raises(DetectorValueError):
d.n_frames = 0 # d.n_frames = -1
def test_n_cycles_without_detector(d): # def test_set_n_frames_raises_on_zero(d, mocker):
assert d.n_cycles == -100 # mocker.patch('_sls_detector.DetectorApi.setNumberOfFrames')
# with pytest.raises(DetectorValueError):
def test_set_n_cycles_raises_on_zero(d, mocker): # d.n_frames = 0
mocker.patch('_sls_detector.DetectorApi.setCycles')
with pytest.raises(DetectorValueError): # def test_n_cycles_without_detector(d):
d.n_cycles = 0 # assert d.n_cycles == -100
def test_set_n_cycles(d, mocker): # def test_set_n_cycles_raises_on_zero(d, mocker):
m = mocker.patch('_sls_detector.DetectorApi.setCycles') # mocker.patch('_sls_detector.DetectorApi.setCycles')
d.n_cycles = 56 # with pytest.raises(DetectorValueError):
m.assert_called_once_with(56) # d.n_cycles = 0
# def test_set_n_cycles(d, mocker):
# m = mocker.patch('_sls_detector.DetectorApi.setCycles')
def test_n_measurements_without_detector(d): # d.n_cycles = 56
assert d.n_measurements == -100 # m.assert_called_once_with(56)
def test_set_n_measurements_raises_on_zero(d, mocker):
mocker.patch('_sls_detector.DetectorApi.setNumberOfMeasurements')
with pytest.raises(DetectorValueError): # def test_n_measurements_without_detector(d):
d.n_measurements = 0 # assert d.n_measurements == -100
def test_set_n_measurements(d, mocker): # def test_set_n_measurements_raises_on_zero(d, mocker):
m = mocker.patch('_sls_detector.DetectorApi.setNumberOfMeasurements') # mocker.patch('_sls_detector.DetectorApi.setNumberOfMeasurements')
d.n_measurements = 560 # with pytest.raises(DetectorValueError):
m.assert_called_once_with(560) # d.n_measurements = 0
def test_get_n_modules_no_detector(d): # def test_set_n_measurements(d, mocker):
assert d.n_modules == 0 # m = mocker.patch('_sls_detector.DetectorApi.setNumberOfMeasurements')
# d.n_measurements = 560
def test_get_n_modules(d, mocker): # m.assert_called_once_with(560)
m = mocker.patch('_sls_detector.DetectorApi.getNumberOfDetectors')
m.return_value = 12 # def test_get_n_modules_no_detector(d):
assert d.n_modules == 12 # assert d.n_modules == 0
def test_get_period_time(d, mocker): # def test_get_n_modules(d, mocker):
m = mocker.patch('_sls_detector.DetectorApi.getPeriod') # m = mocker.patch('_sls_detector.DetectorApi.getNumberOfDetectors')
m.return_value = 130000000 # m.return_value = 12
assert d.period == 0.13 # assert d.n_modules == 12
def test_set_period_time(d, mocker): # def test_get_period_time(d, mocker):
m = mocker.patch('_sls_detector.DetectorApi.setPeriod') # m = mocker.patch('_sls_detector.DetectorApi.getPeriod')
d.period = 1.953 # m.return_value = 130000000
m.assert_called_once_with(1953000000) # assert d.period == 0.13
def test_set_period_time_less_than_zero(d, mocker): # def test_set_period_time(d, mocker):
mocker.patch('_sls_detector.DetectorApi.setPeriod') # m = mocker.patch('_sls_detector.DetectorApi.setPeriod')
with pytest.raises(ValueError): # d.period = 1.953
d.period = -7 # m.assert_called_once_with(1953000000)
# def test_set_period_time_less_than_zero(d, mocker):
def test_get_online(d, mocker): # mocker.patch('_sls_detector.DetectorApi.setPeriod')
m = mocker.patch('_sls_detector.DetectorApi.getOnline') # with pytest.raises(ValueError):
d.online # d.period = -7
m.assert_called_once_with()
def test_set_online(d, mocker): # def test_get_online(d, mocker):
m = mocker.patch('_sls_detector.DetectorApi.setOnline') # m = mocker.patch('_sls_detector.DetectorApi.getOnline')
d.online = True # d.online
m.assert_called_once_with(True) # m.assert_called_once_with()
def test_last_client_ip_no_detector(d): # def test_set_online(d, mocker):
assert d.last_client_ip == '' # m = mocker.patch('_sls_detector.DetectorApi.setOnline')
# d.online = True
def test_last_cliten_ip_call(d, mocker): # m.assert_called_once_with(True)
m = mocker.patch('_sls_detector.DetectorApi.getLastClientIP')
d.last_client_ip # def test_last_client_ip_no_detector(d):
m.assert_called_once_with() # assert d.last_client_ip == ''
#-------------------------------------------------------------Rate correction # def test_last_cliten_ip_call(d, mocker):
def test_get_rate_correction(d, mocker): # m = mocker.patch('_sls_detector.DetectorApi.getLastClientIP')
m = mocker.patch('_sls_detector.DetectorApi.getRateCorrection') # d.last_client_ip
m.return_value = [132,129] # m.assert_called_once_with()
assert d.rate_correction == [132,129]
# #-------------------------------------------------------------Rate correction
def test_set_rate_correction(d, mocker): # def test_get_rate_correction(d, mocker):
m = mocker.patch('_sls_detector.DetectorApi.setRateCorrection') # m = mocker.patch('_sls_detector.DetectorApi.getRateCorrection')
mock_n = mocker.patch('_sls_detector.DetectorApi.getNumberOfDetectors') # m.return_value = [132,129]
mock_n.return_value = 3 # assert d.rate_correction == [132,129]
d.rate_correction = [123,90,50]
m.assert_called_once_with([123,90,50]) # def test_set_rate_correction(d, mocker):
# m = mocker.patch('_sls_detector.DetectorApi.setRateCorrection')
def test_set_rate_correction_raises_on_wrong_number_of_values(d, mocker): # mock_n = mocker.patch('_sls_detector.DetectorApi.getNumberOfDetectors')
mocker.patch('_sls_detector.DetectorApi.setRateCorrection') # mock_n.return_value = 3
mock_n = mocker.patch('_sls_detector.DetectorApi.getNumberOfDetectors') # d.rate_correction = [123,90,50]
mock_n.return_value = 4 # m.assert_called_once_with([123,90,50])
with pytest.raises(ValueError):
d.rate_correction = [123,90,50] # def test_set_rate_correction_raises_on_wrong_number_of_values(d, mocker):
# mocker.patch('_sls_detector.DetectorApi.setRateCorrection')
#----------------------------------------------------------------Readout clock # mock_n = mocker.patch('_sls_detector.DetectorApi.getNumberOfDetectors')
def test_get_readout_clock_0(d, mocker): # mock_n.return_value = 4
m = mocker.patch('_sls_detector.DetectorApi.getReadoutClockSpeed') # with pytest.raises(ValueError):
m.return_value = 0 # d.rate_correction = [123,90,50]
assert d.readout_clock == 'Full Speed'
# #----------------------------------------------------------------Readout clock
def test_get_readout_clock_1(d, mocker): # def test_get_readout_clock_0(d, mocker):
m = mocker.patch('_sls_detector.DetectorApi.getReadoutClockSpeed') # m = mocker.patch('_sls_detector.DetectorApi.getReadoutClockSpeed')
m.return_value = 1 # m.return_value = 0
assert d.readout_clock == 'Half Speed' # assert d.readout_clock == 'Full Speed'
def test_get_readout_clock_2(d, mocker): # def test_get_readout_clock_1(d, mocker):
m = mocker.patch('_sls_detector.DetectorApi.getReadoutClockSpeed') # m = mocker.patch('_sls_detector.DetectorApi.getReadoutClockSpeed')
m.return_value = 2 # m.return_value = 1
assert d.readout_clock == 'Quarter Speed' # assert d.readout_clock == 'Half Speed'
def test_get_readout_clock_3(d, mocker): # def test_get_readout_clock_2(d, mocker):
m = mocker.patch('_sls_detector.DetectorApi.getReadoutClockSpeed') # m = mocker.patch('_sls_detector.DetectorApi.getReadoutClockSpeed')
m.return_value = 3 # m.return_value = 2
assert d.readout_clock == 'Super Slow Speed' # assert d.readout_clock == 'Quarter Speed'
def test_set_readout_clock_0(d, mocker): # def test_get_readout_clock_3(d, mocker):
m = mocker.patch('_sls_detector.DetectorApi.setReadoutClockSpeed') # m = mocker.patch('_sls_detector.DetectorApi.getReadoutClockSpeed')
d.readout_clock = 'Full Speed' # m.return_value = 3
m.assert_called_once_with(0) # assert d.readout_clock == 'Super Slow Speed'
def test_set_readout_clock_1(d, mocker): # def test_set_readout_clock_0(d, mocker):
m = mocker.patch('_sls_detector.DetectorApi.setReadoutClockSpeed') # m = mocker.patch('_sls_detector.DetectorApi.setReadoutClockSpeed')
d.readout_clock = 'Half Speed' # d.readout_clock = 'Full Speed'
m.assert_called_once_with(1) # m.assert_called_once_with(0)
def test_set_readout_clock_2(d, mocker): # def test_set_readout_clock_1(d, mocker):
m = mocker.patch('_sls_detector.DetectorApi.setReadoutClockSpeed') # m = mocker.patch('_sls_detector.DetectorApi.setReadoutClockSpeed')
d.readout_clock = 'Quarter Speed' # d.readout_clock = 'Half Speed'
m.assert_called_once_with(2) # m.assert_called_once_with(1)
def test_set_readout_clock_3(d, mocker): # def test_set_readout_clock_2(d, mocker):
m = mocker.patch('_sls_detector.DetectorApi.setReadoutClockSpeed') # m = mocker.patch('_sls_detector.DetectorApi.setReadoutClockSpeed')
d.readout_clock = 'Super Slow Speed' # d.readout_clock = 'Quarter Speed'
m.assert_called_once_with(3) # m.assert_called_once_with(2)
#----------------------------------------------------------------rx_datastream # def test_set_readout_clock_3(d, mocker):
def test_get_rx_datastream(d, mocker): # m = mocker.patch('_sls_detector.DetectorApi.setReadoutClockSpeed')
m = mocker.patch('_sls_detector.DetectorApi.getRxDataStreamStatus') # d.readout_clock = 'Super Slow Speed'
m.return_value = False # m.assert_called_once_with(3)
assert d.rx_datastream == False
# #----------------------------------------------------------------rx_datastream
def test_set_rx_datastream(d, mocker): # def test_get_rx_datastream(d, mocker):
m = mocker.patch('_sls_detector.DetectorApi.setRxDataStreamStatus') # m = mocker.patch('_sls_detector.DetectorApi.getRxDataStreamStatus')
d.rx_datastream = True # m.return_value = False
m.assert_called_once_with(True) # assert d.rx_datastream == False
def test_get_rx_zmqip(d, mocker): # def test_set_rx_datastream(d, mocker):
m = mocker.patch('_sls_detector.DetectorApi.getNetworkParameter') # m = mocker.patch('_sls_detector.DetectorApi.setRxDataStreamStatus')
d.rx_zmqip # d.rx_datastream = True
m.assert_called_once_with('rx_zmqip') # m.assert_called_once_with(True)
def test_get_rx_zmqport_call(d, mocker): # def test_get_rx_zmqip(d, mocker):
m = mocker.patch('_sls_detector.DetectorApi.getNetworkParameter') # m = mocker.patch('_sls_detector.DetectorApi.getNetworkParameter')
d.rx_zmqport # d.rx_zmqip
m.assert_called_once_with('rx_zmqport') # m.assert_called_once_with('rx_zmqip')
def test_get_rx_zmqport_decode(d, mocker): # def test_get_rx_zmqport_call(d, mocker):
m = mocker.patch('_sls_detector.DetectorApi.getNetworkParameter') # m = mocker.patch('_sls_detector.DetectorApi.getNetworkParameter')
m.return_value = ['30001', '30003'] # d.rx_zmqport
assert d.rx_zmqport == [30001, 30003] # m.assert_called_once_with('rx_zmqport')
def test_get_rx_zmqport_empty(d, mocker): # def test_get_rx_zmqport_decode(d, mocker):
m = mocker.patch('_sls_detector.DetectorApi.getNetworkParameter') # m = mocker.patch('_sls_detector.DetectorApi.getNetworkParameter')
m.return_value = '' # m.return_value = ['30001', '30003']
assert d.rx_zmqport == [] # assert d.rx_zmqport == [30001, 30003]
# def test_get_rx_zmqport_empty(d, mocker):
#--------------------------------------------------------------------status # m = mocker.patch('_sls_detector.DetectorApi.getNetworkParameter')
def test_status_call(d, mocker): # m.return_value = ''
m = mocker.patch('_sls_detector.DetectorApi.getRunStatus') # assert d.rx_zmqport == []
d.status
m.assert_called_once_with()
# #--------------------------------------------------------------------status
def test_start_detecor(d, mocker): # def test_status_call(d, mocker):
m = mocker.patch('_sls_detector.DetectorApi.startAcquisition') # m = mocker.patch('_sls_detector.DetectorApi.getRunStatus')
d.start_detector() # d.status
m.assert_called_once_with() # m.assert_called_once_with()
def test_stop_acq_call(d, mocker): # def test_start_detecor(d, mocker):
m = mocker.patch('_sls_detector.DetectorApi.stopAcquisition') # m = mocker.patch('_sls_detector.DetectorApi.startAcquisition')
d.stop_detector() # d.start_detector()
m.assert_called_once_with() # m.assert_called_once_with()
# def test_stop_acq_call(d, mocker):
# m = mocker.patch('_sls_detector.DetectorApi.stopAcquisition')
#------------------------------------------------------------------timing mode # d.stop_detector()
def test_get_timing_mode(d, mocker): # m.assert_called_once_with()
m = mocker.patch('_sls_detector.DetectorApi.getTimingMode')
d.timing_mode
m.assert_called_once_with()
# #------------------------------------------------------------------timing mode
def test_set_timing_mode(d, mocker): # def test_get_timing_mode(d, mocker):
m = mocker.patch('_sls_detector.DetectorApi.setTimingMode') # m = mocker.patch('_sls_detector.DetectorApi.getTimingMode')
d.timing_mode = 'auto' # d.timing_mode
m.assert_called_once_with('auto') # m.assert_called_once_with()
#----------------------------------------------------------------vthreshold # def test_set_timing_mode(d, mocker):
def test_get_vthreshold(d, mocker): # m = mocker.patch('_sls_detector.DetectorApi.setTimingMode')
m = mocker.patch('_sls_detector.DetectorApi.getDac') # d.timing_mode = 'auto'
d.vthreshold # m.assert_called_once_with('auto')
m.assert_called_once_with('vthreshold', -1)
# #----------------------------------------------------------------vthreshold
def test_set_vthreshold(d, mocker): # def test_get_vthreshold(d, mocker):
m = mocker.patch('_sls_detector.DetectorApi.setDac') # m = mocker.patch('_sls_detector.DetectorApi.getDac')
d.vthreshold = 1675 # d.vthreshold
m.assert_called_once_with('vthreshold', -1, 1675) # m.assert_called_once_with('vthreshold', -1)
# def test_set_vthreshold(d, mocker):
# m = mocker.patch('_sls_detector.DetectorApi.setDac')
# d.vthreshold = 1675
# m.assert_called_once_with('vthreshold', -1, 1675)

20
python/unit-tests/test_utils.py
View File

@ -1,12 +1,12 @@
#!/usr/bin/env python3 #!/usr/bin/env python3
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
""" """
Testing parameters and methods of the Detector class using mocks Testing functions from utils.py
""" """
import pytest import pytest
from sls_detector.utils import eiger_register_to_time from sls_detector.utils import *
from sls_detector.utils import all_equal, element_if_equal
def test_convert_zero(): def test_convert_zero():
assert eiger_register_to_time(0) == 0 assert eiger_register_to_time(0) == 0
@ -47,4 +47,16 @@ def test_element_if_equal_str():
assert element_if_equal('hhh') == 'h' assert element_if_equal('hhh') == 'h'
def test_element_if_equal_int_fails(): def test_element_if_equal_int_fails():
assert element_if_equal([5, 6, 7]) == [5, 6, 7] assert element_if_equal([5, 6, 7]) == [5, 6, 7]
def test_get_set_bits():
assert(get_set_bits(0) == [])
assert get_set_bits(7) == [0, 1, 2]
def test_list_to_mask():
assert(list_to_bitmask([0,1,2]) == 7)
assert(list_to_bitmask([]) == 0)
assert(list_to_bitmask([0]) == 1)
assert(list_to_bitmask([1]) == 2)
assert(list_to_bitmask([3]) == 8)
assert(list_to_bitmask([1,1,1]) == 2)