merging refactor (replacing)

python/unit-tests/dac_test.py

@@ -0,0 +1,173 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Testing setting and getting dacs from the detector
+"""
+from unittest.mock import Mock, call
+import pytest
+from pytest_mock import mocker
+import numpy as np
+
+from sls_detector import Eiger
+from sls_detector import DetectorApi
+
+
+def test_get_vrf_for_three_mod(mocker):
+    m2= mocker.patch.object(DetectorApi, 'getNumberOfDetectors', autospec=True)
+    m2.return_value = 3
+    m = mocker.patch.object(DetectorApi, 'getDac', autospec=True)
+    m.return_value = 1560
+    d = Eiger()
+    vrf = d.dacs.vrf[:]
+    assert vrf == [1560, 1560, 1560]
+    
+def test_set_vrf_for_three_mod_same_value(mocker):
+    m2= mocker.patch.object(DetectorApi, 'getNumberOfDetectors', autospec=True)
+    m2.return_value = 3
+    m = mocker.patch.object(DetectorApi, 'setDac', autospec=True)
+#    m.return_value = 1560
+    d = Eiger()
+    d.dacs.vrf[:] = 1500
+    calls = [call('vrf', 0, 1500), call('vrf', 1, 1500), call('vrf', 2, 1500)]
+    m.assert_has_calls(calls)
+    assert m.call_count == 3
+    
+def test_set_vrf_for_four_mod_different_value(mocker):
+    m2= mocker.patch.object(DetectorApi, 'getNumberOfDetectors', autospec=True)
+    m2.return_value = 4
+    m = mocker.patch.object(DetectorApi, 'setDac', autospec=True)
+#    m.return_value = 1560
+    d = Eiger()
+    d.dacs.vrf =  [1500, 1600, 1800, 1502]
+    calls = [call('vrf', 0, 1500), 
+             call('vrf', 1, 1600), 
+             call('vrf', 2, 1800),
+             call('vrf', 3, 1502)]
+    m.assert_has_calls(calls)
+    assert m.call_count == 4
+    
+def test_set_vrf_for_four_mod_different_value_slice(mocker):
+    m2= mocker.patch.object(DetectorApi, 'getNumberOfDetectors', autospec=True)
+    m2.return_value = 4
+    m = mocker.patch.object(DetectorApi, 'setDac', autospec=True)
+#    m.return_value = 1560
+    d = Eiger()
+    d.dacs.vrf[:] =  [1500, 1600, 1800, 1502]
+    calls = [call('vrf', 0, 1500), 
+             call('vrf', 1, 1600), 
+             call('vrf', 2, 1800),
+             call('vrf', 3, 1502)]
+    m.assert_has_calls(calls)
+    assert m.call_count == 4
+    
+def test_set_vcp_single_call(mocker):
+    m2= mocker.patch.object(DetectorApi, 'getNumberOfDetectors', autospec=True)
+    m2.return_value = 2
+    m = mocker.patch.object(DetectorApi, 'setDac', autospec=True)
+#    m.return_value = 1560
+    d = Eiger()
+    d.dacs.vcp[1] =  1637
+    m.assert_called_once_with('vcp', 1, 1637)
+    
+def test_iterate_on_index_call_vcn(mocker):
+    m2= mocker.patch.object(DetectorApi, 'getNumberOfDetectors', autospec=True)
+    m2.return_value = 10
+    m = mocker.patch.object(DetectorApi, 'setDac', autospec=True)
+#    m.return_value = 1560
+    d = Eiger()
+    d.dacs.vcn[0,3,8] = 1532
+    calls = [call('vcn', 0, 1532), 
+             call('vcn', 3, 1532), 
+             call('vcn', 8, 1532)]
+    m.assert_has_calls(calls)
+    assert m.call_count == 3
+
+def test_set_dac_from_element_in_numpy_array(mocker):
+    m2= mocker.patch.object(DetectorApi, 'getNumberOfDetectors', autospec=True)
+    m2.return_value = 2
+    m = mocker.patch.object(DetectorApi, 'setDac', autospec=True)  
+    d = Eiger()
+    
+    vrf = np.array((1600,1700,1800))
+    d.dacs.vrf = vrf[0]
+    calls = [call('vrf', 0, 1600),
+             call('vrf', 1, 1600),]
+    m.assert_has_calls(calls)
+    assert m.call_count == 2
+
+def test_set_dac_from_element_in_numpy_array_using_slice(mocker):
+    m2= mocker.patch.object(DetectorApi, 'getNumberOfDetectors', autospec=True)
+    m2.return_value = 2
+    m = mocker.patch.object(DetectorApi, 'setDac', autospec=True)  
+    d = Eiger()
+    
+    vrf = np.array((1600,1700,1800))
+    d.dacs.vrf[:] = vrf[0]
+    calls = [call('vrf', 0, 1600),
+             call('vrf', 1, 1600),]
+    m.assert_has_calls(calls)
+    assert m.call_count == 2
+    
+def test_set_eiger_default(mocker):
+    m2= mocker.patch.object(DetectorApi, 'getNumberOfDetectors', autospec=True)
+    m2.return_value = 2
+    m = mocker.patch.object(DetectorApi, 'setDac', autospec=True)
+#    m.return_value = 1560
+    d = Eiger()
+    d.dacs.set_default()
+    calls = [call('vsvp', 0, 0),
+             call('vsvp', 1, 0),
+             call('vtr', 0, 2500),
+             call('vtr', 1, 2500),
+             call('vrf', 0, 3300),
+             call('vrf', 1, 3300),
+             call('vrs', 0, 1400),
+             call('vrs', 1, 1400),
+             call('vsvn', 0, 4000),
+             call('vsvn', 1, 4000),
+             call('vtgstv', 0, 2556),
+             call('vtgstv', 1, 2556),
+             call('vcmp_ll', 0, 1500),
+             call('vcmp_ll', 1, 1500),
+             call('vcmp_lr', 0, 1500),
+             call('vcmp_lr', 1, 1500),
+             call('vcall', 0, 4000),
+             call('vcall', 1, 4000),
+             call('vcmp_rl', 0, 1500),
+             call('vcmp_rl', 1, 1500),
+             call('rxb_rb', 0, 1100),
+             call('rxb_rb', 1, 1100),
+             call('rxb_lb', 0, 1100),
+             call('rxb_lb', 1, 1100),
+             call('vcmp_rr', 0, 1500),
+             call('vcmp_rr', 1, 1500),
+             call('vcp', 0, 200),
+             call('vcp', 1, 200),
+             call('vcn', 0, 2000),
+             call('vcn', 1, 2000),
+             call('vis', 0, 1550),
+             call('vis', 1, 1550),
+             call('iodelay', 0, 660),
+             call('iodelay', 1, 660)]
+
+    m.assert_has_calls(calls)
+    assert m.call_count == 17*2
+    
+def test_set_eiger_set_from_array_call_count(mocker):
+    import numpy as np
+    m2= mocker.patch.object(DetectorApi, 'getNumberOfDetectors', autospec=True)
+    m2.return_value = 3
+    m = mocker.patch.object(DetectorApi, 'setDac', autospec=True)
+#    m.return_value = 1560
+    d = Eiger()
+    d.dacs.set_from_array( np.zeros((17,3)))
+    assert m.call_count == 17*3
+    
+def test_get_fpga_temp(mocker):
+    m2= mocker.patch.object(DetectorApi, 'getNumberOfDetectors', autospec=True)
+    m2.return_value = 2
+    m = mocker.patch.object(DetectorApi, 'getAdc', autospec=True)
+    m.return_value = 34253
+    d = Eiger()
+    t = d.temp.fpga[:]
+    assert t == [34.253, 34.253]

python/unit-tests/detector_eiger.py

@@ -0,0 +1,489 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Testing parameters and methods of the Detector class using mocks
+"""
+from unittest.mock import Mock
+import pytest
+from pytest_mock import mocker
+
+
+
+@pytest.fixture
+def d():
+    from sls_detector import Eiger
+    return Eiger()
+
+
+def test_acq_call(d, mocker):
+    m = mocker.patch('_sls_detector.DetectorApi.acq')
+    d.acq()
+    m.assert_called_once_with()
+
+def test_busy_call(d, mocker):
+    m = mocker.patch('_sls_detector.DetectorApi.getAcquiringFlag')
+    m.return_value = False
+    assert d.busy == False
+
+
+def test_assign_to_detector_type(d):
+    with pytest.raises(AttributeError):
+        d.detector_type = 'Eiger'
+
+def test_det_type(d, mocker):
+    m = mocker.patch('_sls_detector.DetectorApi.getDetectorType')
+    m.return_value = 'Eiger'
+    assert d.detector_type == 'Eiger'
+
+def test_set_dynamic_range_4(d, mocker):
+    m = mocker.patch('_sls_detector.DetectorApi.setDynamicRange')
+    d.dynamic_range = 4
+    m.assert_called_with(4)
+
+def test_set_dynamic_range_8(d, mocker):
+    m = mocker.patch('_sls_detector.DetectorApi.setDynamicRange')
+    d.dynamic_range = 8
+    m.assert_called_with(8)
+
+
+def test_set_dynamic_range_16(d, mocker):
+    m = mocker.patch('_sls_detector.DetectorApi.setDynamicRange')
+    d.dynamic_range = 16
+    m.assert_called_with(16)
+
+def test_set_dynamic_range_32(d, mocker):
+    m = mocker.patch('_sls_detector.DetectorApi.setDynamicRange')
+    d.dynamic_range = 32
+    m.assert_called_with(32)
+
+def test_set_dynamic_range_raises_exception(d, mocker):
+    mocker.patch('_sls_detector.DetectorApi.setDynamicRange')
+    with pytest.raises(ValueError):
+        d.dynamic_range = 17
+
+def test_get_dynamic_range_32(d, mocker):
+    m = mocker.patch('_sls_detector.DetectorApi.getDynamicRange')
+    m.return_value = 32
+    dr = d.dynamic_range
+    assert dr == 32
+
+def test_eiger_matrix_reset(d, mocker):
+    m = mocker.patch('_sls_detector.DetectorApi.getCounterBit')
+    m.return_value = True
+    assert d.eiger_matrix_reset == True
+
+def test_set_eiger_matrix_reset(d, mocker):
+    m = mocker.patch('_sls_detector.DetectorApi.setCounterBit')
+    d.eiger_matrix_reset = True
+    m.assert_called_once_with(True)
+
+
+def test_get_exposure_time(d, mocker):
+    m = mocker.patch('_sls_detector.DetectorApi.getExposureTime')
+    m.return_value = 100000000
+    assert d.exposure_time == 0.1
+
+def test_set_exposure_time(d, mocker):
+    m = mocker.patch('_sls_detector.DetectorApi.setExposureTime')
+    d.exposure_time = 1.5
+    m.assert_called_once_with(1500000000)
+
+def test_set_exposure_time_less_than_zero(d, mocker):
+    mocker.patch('_sls_detector.DetectorApi.setExposureTime')
+    with pytest.raises(ValueError):
+        d.exposure_time = -7
+
+
+def test_get_file_index(d, mocker):
+    m = mocker.patch('_sls_detector.DetectorApi.getFileIndex')
+    m.return_value = 8
+    assert d.file_index == 8
+
+def test_set_file_index(d, mocker):
+    m = mocker.patch('_sls_detector.DetectorApi.setFileIndex')
+    d.file_index = 9
+    m.assert_called_with(9)
+
+
+def test_set_file_index_raises_on_neg(d, mocker):
+    mocker.patch('_sls_detector.DetectorApi.setFileIndex')
+    with pytest.raises(ValueError):
+        d.file_index = -9
+
+
+def test_get_file_name(d, mocker):
+    m = mocker.patch('_sls_detector.DetectorApi.getFileName')
+    d.file_name
+    m.assert_called_once_with()
+
+def test_set_file_name(d, mocker):
+    m = mocker.patch('_sls_detector.DetectorApi.setFileName')
+    d.file_name = 'hej'
+    m.assert_called_once_with('hej')
+
+def test_get_file_path(d, mocker):
+    m = mocker.patch('_sls_detector.DetectorApi.getFilePath')
+    d.file_path
+    m.assert_called_once_with()
+
+def test_set_file_path_when_path_exists(d, mocker):
+    m = mocker.patch('_sls_detector.DetectorApi.setFilePath')
+    #To avoid raising an exception because path is not there
+    mock_os = mocker.patch('os.path.exists')
+    mock_os.return_value = True
+    d.file_path = '/path/to/something/'
+    m.assert_called_once_with('/path/to/something/')
+
+def test_set_file_path_raises_when_not_exists(d, mocker):
+    mocker.patch('_sls_detector.DetectorApi.setFilePath')
+    mock_os = mocker.patch('os.path.exists')
+    mock_os.return_value = False
+    with pytest.raises(FileNotFoundError):
+        d.file_path = '/path/to/something/'
+
+def test_get_file_write(d, mocker):
+    m = mocker.patch('_sls_detector.DetectorApi.getFileWrite')
+    m.return_value = False
+    assert d.file_write == False
+
+def test_set_file_write(d, mocker):
+    m = mocker.patch('_sls_detector.DetectorApi.setFileWrite')
+    d.file_write = True
+    m.assert_called_once_with(True)
+
+
+def test_get_firmware_version(d, mocker):
+    m = mocker.patch('_sls_detector.DetectorApi.getFirmwareVersion')
+    m.return_value = 20
+    assert d.firmware_version == 20
+
+def test_cannot_set_fw_version(d):
+    with pytest.raises(AttributeError):
+        d.firmware_version = 20
+
+def test_get_high_voltage_call_signature(d, mocker):
+    m = mocker.patch('_sls_detector.DetectorApi.getDac')
+    d.high_voltage
+    m.assert_called_once_with('vhighvoltage', -1)
+
+def test_get_high_voltage(d, mocker):
+    m = mocker.patch('_sls_detector.DetectorApi.getDac')
+    m.return_value = 80
+    assert d.high_voltage == 80
+
+#self._api.setDac('vhighvoltage', -1, voltage)
+def test_set_high_voltage(d, mocker):
+    m = mocker.patch('_sls_detector.DetectorApi.setDac')
+    d.high_voltage = 80
+    m.assert_called_once_with('vhighvoltage', -1, 80)
+
+def test_decode_hostname_two_names(d, mocker):
+    m = mocker.patch('_sls_detector.DetectorApi.getHostname')
+    m.return_value = 'beb059+beb048+'
+    assert d.hostname == ['beb059', 'beb048']
+
+def test_decode_hostname_four_names(d, mocker):
+    m = mocker.patch('_sls_detector.DetectorApi.getHostname')
+    m.return_value = 'beb059+beb048+beb120+beb153+'
+    assert d.hostname == ['beb059', 'beb048', 'beb120', 'beb153']
+
+def test_decode_hostname_blank(d, mocker):
+    m = mocker.patch('_sls_detector.DetectorApi.getHostname')
+    m.return_value = ''
+    assert d.hostname == []
+
+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
+    assert im_size.rows == 512
+    assert im_size.cols == 1024
+
+
+
+def test_load_config(d, mocker):
+    m = mocker.patch('_sls_detector.DetectorApi.readConfigurationFile')
+    #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')
+    m.assert_called_once_with('/path/to/my/file.config')
+
+def test_load_config_raises_when_file_is_not_found(d, mocker):
+    mocker.patch('_sls_detector.DetectorApi.readConfigurationFile')
+    mock_os = mocker.patch('os.path.isfile')
+    mock_os.return_value = False
+    with pytest.raises(FileNotFoundError):
+        d.load_config('/path/to/my/file.config')
+
+def test_load_parameters(d, mocker):
+    m = mocker.patch('_sls_detector.DetectorApi.readParametersFile')
+    #To avoid raising an exception because path is not there
+    mock_os = mocker.patch('os.path.isfile')
+    mock_os.return_value = True
+    d.load_parameters('/path/to/my/file.par')
+    m.assert_called_once_with('/path/to/my/file.par')
+
+def test_load_parameters_raises_when_file_is_not_found(d, mocker):
+    mocker.patch('_sls_detector.DetectorApi.readParametersFile')
+    mock_os = mocker.patch('os.path.isfile')
+    mock_os.return_value = False
+    with pytest.raises(FileNotFoundError):
+        d.load_parameters('/path/to/my/file.par')
+
+#getDetectorGeometry
+def test_get_module_geometry_gives_correct_size(d, mocker):
+    m = mocker.patch('_sls_detector.DetectorApi.getDetectorGeometry')
+    m.return_value = (13,7)
+    g = d.module_geometry
+    assert g.vertical == 7
+    assert g.horizontal == 13
+
+def test_get_module_geometry_access(d, mocker):
+    m = mocker.patch('_sls_detector.DetectorApi.getDetectorGeometry')
+    m.return_value = (12,3)
+    assert d.module_geometry[0] == 12
+    assert d.module_geometry[1] == 3
+    assert d.module_geometry.vertical == 3
+    assert d.module_geometry.horizontal == 12
+
+def test_get_n_frames(d, mocker):
+    m = mocker.patch('_sls_detector.DetectorApi.getNumberOfFrames')
+    m.return_value = 3
+    assert d.n_frames == 3
+
+def test_set_n_frames(d, mocker):
+    m = mocker.patch('_sls_detector.DetectorApi.setNumberOfFrames')
+    d.n_frames = 9
+    m.assert_called_once_with(9)
+
+def test_set_n_frames_raises_on_neg(d, mocker):
+    mocker.patch('_sls_detector.DetectorApi.setNumberOfFrames')
+    with pytest.raises(ValueError):
+        d.n_frames = -1
+
+def test_set_n_frames_raises_on_zero(d, mocker):
+    mocker.patch('_sls_detector.DetectorApi.setNumberOfFrames')
+    with pytest.raises(ValueError):
+        d.n_frames = 0
+
+def test_get_n_modules(d, mocker):
+    m = mocker.patch('_sls_detector.DetectorApi.getNumberOfDetectors')
+    m.return_value = 12
+    assert d.n_modules == 12
+
+def test_get_period_time(d, mocker):
+    m = mocker.patch('_sls_detector.DetectorApi.getPeriod')
+    m.return_value = 130000000
+    assert d.period == 0.13
+
+def test_set_period_time(d, mocker):
+    m = mocker.patch('_sls_detector.DetectorApi.setPeriod')
+    d.period = 1.953
+    m.assert_called_once_with(1953000000)
+
+def test_set_period_time_less_than_zero(d, mocker):
+    mocker.patch('_sls_detector.DetectorApi.setPeriod')
+    with pytest.raises(ValueError):
+        d.period = -7
+
+def test_pulse_chip_call(d, mocker):
+    m = mocker.patch('_sls_detector.DetectorApi.pulseChip')
+    d.pulse_chip(15)
+    m.assert_called_once_with(15)
+
+def test_pulse_chip_call_minus_one(d, mocker):
+    m = mocker.patch('_sls_detector.DetectorApi.pulseChip')
+    d.pulse_chip(-1)
+    m.assert_called_once_with(-1)
+
+def test_pulse_chip_asserts_on_smaller_than_minus_one(d, mocker):
+    mocker.patch('_sls_detector.DetectorApi.pulseChip')
+    with pytest.raises(ValueError):
+        d.pulse_chip(-3)
+#--------------------------------------------------------------------subexptime
+def test_get_sub_exposure_time(d, mocker):
+    m = mocker.patch('_sls_detector.DetectorApi.getSubExposureTime')
+    m.return_value = 2370000
+    assert d.sub_exposure_time == 0.00237
+
+
+def test_set_sub_exposure_time(d, mocker):
+    m = mocker.patch('_sls_detector.DetectorApi.setSubExposureTime')
+    d.sub_exposure_time = 0.002
+    m.assert_called_once_with(2000000)
+
+def test_set_sub_exposure_time_raises_on_zero(d, mocker):
+    mocker.patch('_sls_detector.DetectorApi.setSubExposureTime')
+    with pytest.raises(ValueError):
+        d.sub_exposure_time = 0
+
+#-------------------------------------------------------------Rate correction
+def test_get_rate_correction(d, mocker):
+    m = mocker.patch('_sls_detector.DetectorApi.getRateCorrection')
+    m.return_value = [132,129]
+    assert d.rate_correction == [132,129]
+
+def test_set_rate_correction(d, mocker):
+    m = mocker.patch('_sls_detector.DetectorApi.setRateCorrection')
+    mock_n = mocker.patch('_sls_detector.DetectorApi.getNumberOfDetectors')
+    mock_n.return_value = 3
+    d.rate_correction = [123,90,50]
+    m.assert_called_once_with([123,90,50])
+
+def test_set_rate_correction_raises_on_wrong_number_of_values(d, mocker):
+    mocker.patch('_sls_detector.DetectorApi.setRateCorrection')
+    mock_n = mocker.patch('_sls_detector.DetectorApi.getNumberOfDetectors')
+    mock_n.return_value = 4
+    with pytest.raises(ValueError):
+        d.rate_correction = [123,90,50]
+
+#----------------------------------------------------------------Readout clock
+def test_get_readout_clock_0(d, mocker):
+    m = mocker.patch('_sls_detector.DetectorApi.getReadoutClockSpeed')
+    m.return_value = 0
+    assert d.readout_clock == 'Full Speed'
+
+def test_get_readout_clock_1(d, mocker):
+    m = mocker.patch('_sls_detector.DetectorApi.getReadoutClockSpeed')
+    m.return_value = 1
+    assert d.readout_clock == 'Half Speed'
+
+def test_get_readout_clock_2(d, mocker):
+    m = mocker.patch('_sls_detector.DetectorApi.getReadoutClockSpeed')
+    m.return_value = 2
+    assert d.readout_clock == 'Quarter Speed'
+
+def test_get_readout_clock_3(d, mocker):
+    m = mocker.patch('_sls_detector.DetectorApi.getReadoutClockSpeed')
+    m.return_value = 3
+    assert d.readout_clock == 'Super Slow Speed'
+
+def test_set_readout_clock_0(d, mocker):
+    m = mocker.patch('_sls_detector.DetectorApi.setReadoutClockSpeed')
+    d.readout_clock = 'Full Speed'
+    m.assert_called_once_with(0)
+
+def test_set_readout_clock_1(d, mocker):
+    m = mocker.patch('_sls_detector.DetectorApi.setReadoutClockSpeed')
+    d.readout_clock = 'Half Speed'
+    m.assert_called_once_with(1)
+
+def test_set_readout_clock_2(d, mocker):
+    m = mocker.patch('_sls_detector.DetectorApi.setReadoutClockSpeed')
+    d.readout_clock = 'Quarter Speed'
+    m.assert_called_once_with(2)
+
+def test_set_readout_clock_3(d, mocker):
+    m = mocker.patch('_sls_detector.DetectorApi.setReadoutClockSpeed')
+    d.readout_clock = 'Super Slow Speed'
+    m.assert_called_once_with(3)
+
+#----------------------------------------------------------------rx_datastream
+def test_get_rx_datastream(d, mocker):
+    m = mocker.patch('_sls_detector.DetectorApi.getRxDataStreamStatus')
+    m.return_value = False
+    assert d.rx_datastream == False
+
+def test_set_rx_datastream(d, mocker):
+    m = mocker.patch('_sls_detector.DetectorApi.setRxDataStreamStatus')
+    d.rx_datastream = True
+    m.assert_called_once_with(True)
+
+def test_get_rx_zmqip(d, mocker):
+    m = mocker.patch('_sls_detector.DetectorApi.getNetworkParameter')
+    d.rx_zmqip
+    m.assert_called_once_with('rx_zmqip')
+
+def test_get_rx_zmqport_call(d, mocker):
+    m = mocker.patch('_sls_detector.DetectorApi.getNetworkParameter')
+    d.rx_zmqport
+    m.assert_called_once_with('rx_zmqport')
+
+def test_get_rx_zmqport_decode(d, mocker):
+    m = mocker.patch('_sls_detector.DetectorApi.getNetworkParameter')
+    m.return_value = '30001+30003+'
+    assert d.rx_zmqport == [30001, 30002, 30003, 30004]
+
+def test_get_rx_zmqport_empty(d, mocker):
+    m = mocker.patch('_sls_detector.DetectorApi.getNetworkParameter')
+    m.return_value = ''
+    assert d.rx_zmqport == []
+
+
+#--------------------------------------------------------------------status
+def test_status_call(d, mocker):
+    m = mocker.patch('_sls_detector.DetectorApi.getRunStatus')
+    d.status
+    m.assert_called_once_with()
+
+def test_start_acq_call(d, mocker):
+    m = mocker.patch('_sls_detector.DetectorApi.startAcquisition')
+    d.start_acq()
+    m.assert_called_once_with()
+
+def test_stop_acq_call(d, mocker):
+    m = mocker.patch('_sls_detector.DetectorApi.stopAcquisition')
+    d.stop_acq()
+    m.assert_called_once_with()
+
+#--------------------------------------------------------------------subexptime
+def test_get_sub_exposure_time(d, mocker):
+    m = mocker.patch('_sls_detector.DetectorApi.getSubExposureTime')
+    m.return_value = 2370000
+    assert d.sub_exposure_time == 0.00237
+
+
+def test_set_sub_exposure_time(d, mocker):
+    m = mocker.patch('_sls_detector.DetectorApi.setSubExposureTime')
+    d.sub_exposure_time = 0.002
+    m.assert_called_once_with(2000000)
+
+def test_set_sub_exposure_time_raises_on_zero(d, mocker):
+    mocker.patch('_sls_detector.DetectorApi.setSubExposureTime')
+    with pytest.raises(ValueError):
+        d.sub_exposure_time = 0
+
+#------------------------------------------------------------------timing mode
+def test_get_timing_mode(d, mocker):
+    m = mocker.patch('_sls_detector.DetectorApi.getTimingMode')
+    d.timing_mode
+    m.assert_called_once_with()
+
+def test_set_timing_mode(d, mocker):
+    m = mocker.patch('_sls_detector.DetectorApi.setTimingMode')
+    d.timing_mode = 'auto'
+    m.assert_called_once_with('auto')
+
+#----------------------------------------------------------------vthreshold
+def test_get_vthreshold(d, mocker):
+    m = mocker.patch('_sls_detector.DetectorApi.getDac')
+    d.vthreshold
+    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)
+
+#----------------------------------------------------------------trimbits
+def test_get_trimbits(d, mocker):
+    m = mocker.patch('_sls_detector.DetectorApi.getAllTrimbits')
+    d.trimbits
+    m.assert_called_once_with()
+
+def test_set_trimbits(d, mocker):
+    m = mocker.patch('_sls_detector.DetectorApi.setAllTrimbits')
+    d.trimbits = 15
+    m.assert_called_once_with(15)
+
+def test_set_trimbits_raises_outside_range(d, mocker):
+    mocker.patch('_sls_detector.DetectorApi.setAllTrimbits')
+
+    with pytest.raises(ValueError):
+        d.trimbits = 69
+
+    with pytest.raises(ValueError):
+        d.trimbits = -5
+
+

python/unit-tests/detector_test.py

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

python/unit-tests/test_detector_property.py

@@ -0,0 +1,76 @@
+import pytest
+from sls_detector.detector_property import DetectorProperty
+
+class Holder:
+    """
+    This class does nothing except hold values
+    for testing of the DetectorProperty class
+    """
+    def __init__(self, N):
+        self.values = [i for i in range(N)]
+    def get(self, i):
+        return self.values[i]
+    def set(self, i,v):
+        self.values[i] = v
+    def nmod(self):
+        return len(self.values)
+
+@pytest.fixture
+def p():
+    h = Holder(5)
+    return DetectorProperty(h.get, h.set, h.nmod, 'prop')
+
+def test_initialization():
+    def getf(i):
+        return 5
+    def setf():
+        return
+    def nmod():
+        return 3
+    name = 'a property'
+    p = DetectorProperty(getf, setf, nmod, name)
+    assert p.get == getf
+    assert p.set == setf
+    assert p.get_nmod == nmod
+    assert p.__name__ == name
+
+def test_get_single_value(p):
+    assert p[2] == 2
+
+def test_get_all_values(p):
+    assert p[:] == [0, 1, 2, 3, 4]
+
+def test_get_values_by_iterable(p):
+    vals = p[1,3]
+    assert vals == [1,3]
+
+def test_set_single_value(p):
+    p[2] = 7
+    assert p[:] == [0,1,7,3,4]
+ 
+def test_set_all(p):
+     p[:] = 10
+     assert p[:] == [10,10,10,10,10]
+
+def test_set_all_by_list(p):
+    p[:] = [7,8,9,10,11]
+    assert p[:] == [7,8,9,10,11]
+
+def test_set_all_bool(p):
+    p[:] = True
+    assert p[:] == [True]*5
+
+def test_set_by_iter(p):
+    keys = [2,4]
+    vals = [18,23]
+    p[keys] = vals
+    assert p[:] == [0,1,18,3,23]
+
+def test_set_by_iter_single_val(p):
+    keys = [2,4]
+    val = 9
+    p[keys] = val
+    assert p[:] == [0,1,9,3,9]
+
+def test_print_values(p):
+    assert repr(p) == 'prop: [0, 1, 2, 3, 4]'

python/unit-tests/test_utils.py

@@ -0,0 +1,50 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Testing parameters and methods of the Detector class using mocks
+"""
+
+import pytest
+from sls_detector.utils import eiger_register_to_time
+from sls_detector.utils import all_equal, element_if_equal
+
+def test_convert_zero():
+    assert eiger_register_to_time(0) == 0
+
+def test_convert_smallest_unit():
+    assert pytest.approx(eiger_register_to_time(0b1000), 1e-9) == 1e-8
+
+def test_convert_second_smallest_unit():
+    assert pytest.approx(eiger_register_to_time(0b10000), 1e-9) == 2e-8
+
+def test_convert_one_ms_using_exponent():
+    assert pytest.approx(eiger_register_to_time(0b1101), 1e-9) == 1e-3
+
+def test_convert_five_seconds():
+    assert pytest.approx(eiger_register_to_time(0b1001110001000101), 1e-9) == 5.0
+
+def test_all_equal_int():
+    assert all_equal([5,5]) == True
+
+def test_all_equal_fails():
+    assert all_equal([5,6])  == False
+
+def test_all_equal_tuple():
+    assert all_equal(('a', 'a', 'a')) == True
+
+def test_all_equal_str():
+    assert all_equal('aaa') == True
+
+def test_all_equal_str_fails():
+    assert all_equal('aaab') == False
+
+
+
+def test_element_if_equal_int():
+    assert element_if_equal([5,5]) == 5
+
+def test_element_if_equal_str():
+    assert element_if_equal('hhh') == 'h'
+
+def test_element_if_equal_int_fails():
+    assert element_if_equal([5, 6, 7]) == [5, 6, 7]