# # This file is part of the PyMeasure package. # # Copyright (c) 2013-2024 PyMeasure Developers # # Permission is hereby granted, free of charge, to any person obtaining a copy # of this software and associated documentation files (the "Software"), to deal # in the Software without restriction, including without limitation the rights # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell # copies of the Software, and to permit persons to whom the Software is # furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included in # all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN # THE SOFTWARE. # import time import pytest import math from pymeasure.instruments.keithley.keithley2306 import Keithley2306 pytest.skip('Only work with connected hardware', allow_module_level=True) class TestKeithley2306: """ Unit tests for Keithley2306 class. This test suite, needs the following setup to work properly: - A Keithley2306 device should be connected to the computer; - The device's address must be set in the RESOURCE constant; """ ################################################## # Keithley2306 device address goes here: RESOURCE = "USB0::10893::6039::CN57266430::INSTR" ################################################## ######################### # PARAMETRIZATION CASES # ######################### CHANNELS = [1, 2] RELAYS = [1, 2, 3, 4] BOOLEANS = [False, True] BRIGHTNESSES = [0, 0.12, 0.25, 0.3, 0.5, 0.6, 0.75, 0.8, 1] DISPLAY_TEXT_DATAS = ['', 'Hello', '0123456789012345678901234578901'] BANDWIDTHS = ['high', 'low'] IMPEDANCES = [0, 0.01, 0.1, 0.2, 0.25, 0.5, 0.77, 0.99, 1] SENSE_MODES = ['voltage', 'current', 'dvm'] NPLCS = [0.01, 0.1, 1, 2, 4, 10] AVERAGE_COUNTS = [1, 2, 5, 10] CURRENT_RANGES = [0.005, 5] PULSE_CURRENT_AVERAGE_COUNTS = [1, 2, 5, 100, 500, 1000, 5000] PULSE_CURRENT_MODES = ['high', 'low', 'average'] PULSE_CURRENT_TIMES = [33.33333e-06, 1.2E-3, 0.8333] PULSE_CURRENT_STEP_COUNTS = [0, 1, 5, 19] PULSE_CURRENT_STEP_TIMES = [33.33333e-06, 1.2E-3, 100e-3] PULSE_CURRENT_STEP_TIMEOUTS = [2e-3, 20.1e-3, 200e-3] PULSE_CURRENT_STEP_TIMEOUT_INITIALS = [10e-3, 210.3e-3, 60] PULSE_CURRENT_STEP_DELAYS = [0, 10e-3, 57.32e-3, 100e-3] PULSE_CURRENT_STEP_RANGES = [100e-3, 1, 5] PULSE_CURRENT_STEP_INDICES = [1, 2, 5, 20] PULSE_CURRENT_STEP_TRIGGER_LEVELS = [0, 50e-3, 100e-3, 500e-3, 1, 2.5, 5] PULSE_CURRENT_TRIGGER_DELAYS = [0, 0.05, 0.1, 1, 2, 5] PULSE_CURRENT_TRIGGER_LEVELS = [0, 50e-3, 100e-3, 500e-3, 1, 2.5, 5] PULSE_CURRENT_TRIGGER_LEVEL_RANGES = [100e-3, 1, 5] PULSE_CURRENT_TIMEOUTS = [0.005, 1, 32] LONG_INTEGRATION_TRIGGER_EDGES = ['rising', 'falling', 'neither'] LONG_INTEGRATION_TIMES = [0.850, 1, 30, 60] LONG_INTEGRATION_TRIGGER_LEVELS = [0, 50e-3, 100e-3, 500e-3, 1, 2.5, 5] LONG_INTEGRATION_TIMEOUTS = [1, 30, 63] LONG_INTEGRATION_TRIGGER_LEVEL_RANGES = [100e-3, 1, 5] SOURCE_VOLTAGES = [0, 3.3, 15] SOURCE_VOLTAGE_PROTECTIONS = [0, 4, 8] SOURCE_CURRENTS = [0.006, 1, 5] SOURCE_CURRENT_LIMIT_TYPES = ['limit', 'trip'] INSTR = Keithley2306(RESOURCE) ############ # FIXTURES # ############ def reset_display(self): self.INSTR.display_enabled = True self.INSTR.display_text_enabled = False self.INSTR.display_text_data = '' self.INSTR.display_brightness = 1.0 def reset_relays(self): for i in range(1, 5): self.INSTR.relay(i).closed = False @pytest.fixture def instr(self): self.INSTR.reset() return self.INSTR ######### # TESTS # ######### @pytest.mark.parametrize("case", BOOLEANS) def test_display_enabled(self, instr, case): try: assert instr.display_enabled instr.display_enabled = case assert instr.display_enabled == case finally: self.reset_display() @pytest.mark.parametrize("case", BRIGHTNESSES) def test_display_brightness(self, instr, case): try: assert instr.display_brightness == 1.0 instr.display_brightness = case assert instr.display_brightness == math.ceil(4 * case) / 4 finally: self.reset_display() @pytest.mark.parametrize("case", CHANNELS) def test_display_channel(self, instr, case): assert instr.display_channel == 1 instr.display_channel = case assert instr.display_channel == case @pytest.mark.parametrize("display_text_data", DISPLAY_TEXT_DATAS) @pytest.mark.parametrize("case", BOOLEANS) def test_display_text(self, instr, display_text_data, case): try: assert instr.display_text_data == '' assert not instr.display_text_enabled instr.display_text_data = display_text_data instr.display_text_enabled = case assert instr.display_text_data == display_text_data assert instr.display_text_enabled == case finally: self.reset_display() @pytest.mark.parametrize("channel", CHANNELS) @pytest.mark.parametrize("case", BOOLEANS) def test_output_enabled(self, instr, channel, case): assert not instr.ch(channel).enabled instr.ch(channel).enabled = case assert instr.ch(channel).enabled == case @pytest.mark.parametrize("channel", CHANNELS) @pytest.mark.parametrize("case", BANDWIDTHS) def test_output_bandwidth(self, instr, channel, case): instr = instr assert instr.ch(channel).bandwidth == 'low' if channel == 1 else 'high' instr.ch(channel).bandwidth = case assert instr.ch(channel).bandwidth == case @pytest.mark.parametrize("case", IMPEDANCES) def test_output_impedance(self, instr, case): assert instr.ch1.impedance == 0.0 instr.ch1.impedance = case assert instr.ch1.impedance == case @pytest.mark.parametrize("relay", RELAYS) @pytest.mark.parametrize("case", BOOLEANS) def test_relay_closed(self, instr, relay, case): try: assert not instr.relay(relay).closed instr.relay(relay).closed = case assert instr.relay(relay).closed == case finally: self.reset_relays() @pytest.mark.parametrize("case", BOOLEANS) def test_both_channels_enabled(self, instr, case): assert not instr.ch1.enabled assert not instr.ch2.enabled instr.both_channels_enabled = case assert instr.ch1.enabled == case assert instr.ch2.enabled == case @pytest.mark.parametrize("channel", CHANNELS) @pytest.mark.parametrize("case", SENSE_MODES) def test_sense_mode(self, instr, channel, case): assert instr.ch(channel).sense_mode == 'voltage' instr.ch(channel).sense_function = case assert instr.ch(channel).sense_function == case @pytest.mark.parametrize("channel", CHANNELS) @pytest.mark.parametrize("case", NPLCS) def test_nplc(self, instr, channel, case): assert instr.ch(channel).nplc == 1 instr.ch(channel).nplc = case time.sleep(0.5) assert instr.ch(channel).nplc == case instr.ch(channel).nplc == 1 @pytest.mark.parametrize("channel", CHANNELS) @pytest.mark.parametrize("case", AVERAGE_COUNTS) def test_average_count(self, instr, channel, case): assert instr.ch(channel).average_count == 1 instr.ch(channel).average_count = case assert instr.ch(channel).average_count == case @pytest.mark.parametrize("channel", CHANNELS) @pytest.mark.parametrize("case", CURRENT_RANGES) def test_current_range(self, instr, channel, case): assert instr.ch(channel).current_range == 5 instr.ch(channel).current_range = case assert instr.ch(channel).current_range == case @pytest.mark.parametrize("channel", CHANNELS) @pytest.mark.parametrize("case", BOOLEANS) def test_current_range_auto(self, instr, channel, case): assert not instr.ch(channel).current_range_auto instr.ch(channel).current_range_auto = case assert instr.ch(channel).current_range_auto == case @pytest.mark.parametrize("channel", CHANNELS) @pytest.mark.parametrize("pulse_current_measure_enabled", BOOLEANS) @pytest.mark.parametrize("case", PULSE_CURRENT_AVERAGE_COUNTS) def test_pulse_current_average_count(self, instr, channel, pulse_current_measure_enabled, case): instr.ch(channel).pulse_current_fast_enabled = True assert instr.ch(channel).pulse_current_average_count == 1 instr.ch(channel).pulse_current_measure_enabled = pulse_current_measure_enabled if not pulse_current_measure_enabled or case <= 100: instr.ch(channel).pulse_current_average_count = case assert instr.ch(channel).pulse_current_average_count == case @pytest.mark.parametrize("channel", CHANNELS) @pytest.mark.parametrize("case", BOOLEANS) def test_pulse_current_measure_enabled(self, instr, channel, case): instr.ch(channel).pulse_current_fast_enabled = True assert instr.ch(channel).pulse_current_measure_enabled instr.ch(channel).pulse_current_measure_enabled = case assert instr.ch(channel).pulse_current_measure_enabled == case @pytest.mark.parametrize("channel", CHANNELS) @pytest.mark.parametrize("case", PULSE_CURRENT_MODES) def test_pulse_current_mode(self, instr, channel, case): instr.ch(channel).pulse_current_fast_enabled = True assert instr.ch(channel).pulse_current_mode == 'high' instr.ch(channel).pulse_current_mode = case assert instr.ch(channel).pulse_current_mode == case @pytest.mark.parametrize("channel", CHANNELS) @pytest.mark.parametrize("case", PULSE_CURRENT_TIMES) def test_pulse_current_time_high(self, instr, channel, case): instr.ch(channel).pulse_current_fast_enabled = True assert instr.ch(channel).pulse_current_time_high == 33.33333e-06 instr.ch(channel).pulse_current_time_high = case assert instr.ch(channel).pulse_current_time_high == case @pytest.mark.parametrize("channel", CHANNELS) @pytest.mark.parametrize("case", PULSE_CURRENT_TIMES) def test_pulse_current_time_low(self, instr, channel, case): instr.ch(channel).pulse_current_fast_enabled = True assert instr.ch(channel).pulse_current_time_low == 33.33333e-06 instr.ch(channel).pulse_current_time_low = case assert instr.ch(channel).pulse_current_time_low == case @pytest.mark.parametrize("channel", CHANNELS) @pytest.mark.parametrize("case", PULSE_CURRENT_TIMES) def test_pulse_current_time_average(self, instr, channel, case): instr.ch(channel).pulse_current_fast_enabled = True assert instr.ch(channel).pulse_current_time_average == 33.33333e-06 instr.ch(channel).pulse_current_time_average = case assert instr.ch(channel).pulse_current_time_average == case @pytest.mark.parametrize("channel", CHANNELS) @pytest.mark.parametrize("case", PULSE_CURRENT_TIMES) def test_pulse_current_time_digitize(self, instr, channel, case): instr.ch(channel).pulse_current_fast_enabled = True assert instr.ch(channel).pulse_current_time_digitize == 33.33333e-06 instr.ch(channel).pulse_current_time_digitize = case assert instr.ch(channel).pulse_current_time_digitize == case @pytest.mark.parametrize("case", BOOLEANS) def test_pulse_current_step_enabled(self, instr, case): instr.ch1.pulse_current_fast_enabled = True assert not instr.ch1.pulse_current_step_enabled instr.ch1.pulse_current_step_enabled = case assert instr.ch1.pulse_current_step_enabled == case @pytest.mark.parametrize("case", PULSE_CURRENT_STEP_COUNTS) def test_pulse_current_step_up_count(self, instr, case): instr.ch1.pulse_current_fast_enabled = True assert instr.ch1.pulse_current_step_up_count == 1 instr.ch1.pulse_current_step_up_count = case assert instr.ch1.pulse_current_step_up_count == case @pytest.mark.parametrize("case", PULSE_CURRENT_STEP_COUNTS) def test_pulse_current_step_down_count(self, instr, case): instr.ch1.pulse_current_fast_enabled = True assert instr.ch1.pulse_current_step_down_count == 1 instr.ch1.pulse_current_step_down_count = case assert instr.ch1.pulse_current_step_down_count == case @pytest.mark.parametrize("case", PULSE_CURRENT_STEP_TIMES) def test_pulse_current_step_time(self, instr, case): instr.ch1.pulse_current_fast_enabled = True assert instr.ch1.pulse_current_step_time == 200e-6 instr.ch1.pulse_current_step_time = case assert instr.ch1.pulse_current_step_time == case @pytest.mark.parametrize("case", PULSE_CURRENT_STEP_TIMEOUTS) def test_pulse_current_step_timeout(self, instr, case): instr.ch1.pulse_current_fast_enabled = True assert instr.ch1.pulse_current_step_timeout == 2e-3 instr.ch1.pulse_current_step_timeout = case assert instr.ch1.pulse_current_step_timeout == case @pytest.mark.parametrize("case", PULSE_CURRENT_STEP_TIMEOUT_INITIALS) def test_pulse_current_step_timeout_initial(self, instr, case): instr.ch1.pulse_current_fast_enabled = True assert instr.ch1.pulse_current_step_timeout_initial == 2 instr.ch1.pulse_current_step_timeout_initial = case assert instr.ch1.pulse_current_step_timeout_initial == case @pytest.mark.parametrize("case", PULSE_CURRENT_STEP_DELAYS) def test_pulse_current_step_delay(self, instr, case): instr.ch1.pulse_current_fast_enabled = True assert instr.ch1.pulse_current_step_delay == 0 instr.ch1.pulse_current_step_delay = case assert instr.ch1.pulse_current_step_delay == case @pytest.mark.parametrize("case", PULSE_CURRENT_STEP_RANGES) def test_pulse_current_step_range(self, instr, case): instr.ch1.pulse_current_fast_enabled = True assert instr.ch1.pulse_current_step_range == 5 instr.ch1.pulse_current_step_range = case assert instr.ch1.pulse_current_step_range == case @pytest.mark.parametrize("range", PULSE_CURRENT_STEP_RANGES) @pytest.mark.parametrize("step", PULSE_CURRENT_STEP_INDICES) @pytest.mark.parametrize("case", PULSE_CURRENT_STEP_TRIGGER_LEVELS) def test_pulse_current_step_trigger_level(self, instr, range, step, case): instr.ch1.pulse_current_fast_enabled = True assert instr.ch1.pulse_current_step(step).trigger_level == 0.0 if case <= range: instr.ch1.pulse_current_step(step).trigger_level = case assert instr.ch1.pulse_current_step(step).trigger_level == case @pytest.mark.parametrize("channel", CHANNELS) @pytest.mark.parametrize("pulse_current_measure_enabled", BOOLEANS) @pytest.mark.parametrize("case", PULSE_CURRENT_TRIGGER_DELAYS) def test_pulse_current_trigger_delay(self, instr, channel, pulse_current_measure_enabled, case): instr.ch(channel).pulse_current_fast_enabled = True assert instr.ch(channel).pulse_current_trigger_delay == 0 instr.ch(channel).pulse_current_measure_enabled = pulse_current_measure_enabled if not pulse_current_measure_enabled or case <= 0.1: instr.ch(channel).pulse_current_trigger_delay = case assert instr.ch(channel).pulse_current_trigger_delay == case @pytest.mark.parametrize("case", PULSE_CURRENT_TRIGGER_LEVEL_RANGES) def test_pulse_current_trigger_level_range(self, instr, case): instr.ch1.pulse_current_fast_enabled = True assert instr.ch1.pulse_current_trigger_level_range == 5 instr.ch1.pulse_current_trigger_level_range = case assert instr.ch1.pulse_current_trigger_level_range == case @pytest.mark.parametrize("channel", CHANNELS) @pytest.mark.parametrize("case", PULSE_CURRENT_TRIGGER_LEVELS) def test_pulse_current_trigger_level(self, instr, channel, case): instr.ch(channel).pulse_current_fast_enabled = True assert instr.ch(channel).pulse_current_trigger_level == 0 instr.ch(channel).pulse_current_trigger_level = case assert instr.ch(channel).pulse_current_trigger_level == case @pytest.mark.parametrize("channel", CHANNELS) @pytest.mark.parametrize("case", BOOLEANS) def test_pulse_current_fast_enabled(self, instr, channel, case): assert not instr.ch(channel).pulse_current_fast_enabled instr.ch(channel).pulse_current_fast_enabled = case assert instr.ch(channel).pulse_current_fast_enabled == case @pytest.mark.parametrize("channel", CHANNELS) @pytest.mark.parametrize("case", BOOLEANS) def test_pulse_current_search_enabled(self, instr, channel, case): instr.ch(channel).pulse_current_fast_enabled = True assert instr.ch(channel).pulse_current_search_enabled instr.ch(channel).pulse_current_search_enabled = case assert instr.ch(channel).pulse_current_search_enabled == case @pytest.mark.parametrize("channel", CHANNELS) @pytest.mark.parametrize("case", BOOLEANS) def test_pulse_current_detect_enabled(self, instr, channel, case): instr.ch(channel).pulse_current_fast_enabled = True assert not instr.ch(channel).pulse_current_detect_enabled instr.ch(channel).pulse_current_detect_enabled = case assert instr.ch(channel).pulse_current_detect_enabled == case @pytest.mark.parametrize("channel", CHANNELS) @pytest.mark.parametrize("case", PULSE_CURRENT_TIMEOUTS) def test_pulse_current_timeouts(self, instr, channel, case): instr.ch(channel).pulse_current_fast_enabled = True assert instr.ch(channel).pulse_current_timeout == 1 instr.ch(channel).pulse_current_timeout = case assert instr.ch(channel).pulse_current_timeout == case @pytest.mark.parametrize("channel", CHANNELS) @pytest.mark.parametrize("case", LONG_INTEGRATION_TRIGGER_EDGES) def test_long_integration_trigger_edge(self, instr, channel, case): instr.ch(channel).long_integration_fast_enabled = True assert instr.ch(channel).long_integration_trigger_edge == 'rising' instr.ch(channel).long_integration_trigger_edge = case assert instr.ch(channel).long_integration_trigger_edge == case @pytest.mark.parametrize("channel", CHANNELS) @pytest.mark.parametrize("case", LONG_INTEGRATION_TIMES) def test_long_integration_time(self, instr, channel, case): instr.ch(channel).long_integration_fast_enabled = True assert instr.ch(channel).long_integration_time == 1.0 instr.ch(channel).long_integration_time = case assert instr.ch(channel).long_integration_time == case @pytest.mark.parametrize("channel", CHANNELS) @pytest.mark.parametrize("case", LONG_INTEGRATION_TRIGGER_LEVELS) def test_long_integration_trigger_level(self, instr, channel, case): instr.ch(channel).long_integration_fast_enabled = True instr.ch(channel).long_integration_timeout = 1 assert instr.ch(channel).long_integration_trigger_level == 0 instr.ch(channel).long_integration_trigger_level = case assert instr.ch(channel).long_integration_trigger_level == case @pytest.mark.parametrize("channel", CHANNELS) @pytest.mark.parametrize("case", LONG_INTEGRATION_TIMEOUTS) def test_long_integration_timeout(self, instr, channel, case): instr.ch(channel).long_integration_fast_enabled = True assert instr.ch(channel).long_integration_timeout == 16 instr.ch(channel).long_integration_timeout = case assert instr.ch(channel).long_integration_timeout == case @pytest.mark.parametrize("channel", CHANNELS) @pytest.mark.parametrize("case", BOOLEANS) def test_long_integration_fast_enabled(self, instr, channel, case): assert not instr.ch(channel).long_integration_fast_enabled instr.ch(channel).long_integration_fast_enabled = case assert instr.ch(channel).long_integration_fast_enabled == case @pytest.mark.parametrize("channel", CHANNELS) @pytest.mark.parametrize("case", BOOLEANS) def test_long_integration_search_enabled(self, instr, channel, case): instr.ch(channel).long_integration_fast_enabled = True assert instr.ch(channel).long_integration_search_enabled instr.ch(channel).long_integration_search_enabled = case assert instr.ch(channel).long_integration_search_enabled == case @pytest.mark.parametrize("channel", CHANNELS) @pytest.mark.parametrize("case", BOOLEANS) def test_long_integration_detect_enabled(self, instr, channel, case): instr.ch(channel).long_integration_fast_enabled = True assert not instr.ch(channel).long_integration_detect_enabled instr.ch(channel).long_integration_detect_enabled = case assert instr.ch(channel).long_integration_detect_enabled == case @pytest.mark.parametrize("case", LONG_INTEGRATION_TRIGGER_LEVEL_RANGES) def test_long_integration_trigger_level_range(self, instr, case): instr.ch1.long_integration_fast_enabled = True instr.ch1.long_integration_timeout = 1 assert instr.ch1.long_integration_trigger_level_range == 5 instr.ch1.long_integration_trigger_level_range = case assert instr.ch1.long_integration_trigger_level_range == case @pytest.mark.parametrize("channel", CHANNELS) @pytest.mark.parametrize("case", SOURCE_VOLTAGES) def test_source_voltage(self, instr, channel, case): assert instr.ch(channel).source_voltage == 0 instr.ch(channel).source_voltage = case assert instr.ch(channel).source_voltage == case @pytest.mark.parametrize("channel", CHANNELS) @pytest.mark.parametrize("case", SOURCE_VOLTAGE_PROTECTIONS) def test_source_voltage_protection(self, instr, channel, case): assert instr.ch(channel).source_voltage_protection == 8 instr.ch(channel).source_voltage_protection = case assert instr.ch(channel).source_voltage_protection == case @pytest.mark.parametrize("channel", CHANNELS) def test_source_voltage_protection_enabled(self, instr, channel): assert not instr.ch(channel).source_voltage_protection_enabled assert isinstance(instr.ch(channel).source_voltage_protection_enabled, bool) @pytest.mark.parametrize("channel", CHANNELS) @pytest.mark.parametrize("case", BOOLEANS) def test_source_voltage_protection_clamp_enabled(self, instr, channel, case): assert not instr.ch(channel).source_voltage_protection_clamp_enabled instr.ch(channel).source_voltage_protection_clamp_enabled = case assert instr.ch(channel).source_voltage_protection_clamp_enabled == case @pytest.mark.parametrize("channel", CHANNELS) @pytest.mark.parametrize("case", SOURCE_CURRENTS) def test_source_current_limit(self, instr, channel, case): assert instr.ch(channel).source_current_limit == 0.25 instr.ch(channel).source_current_limit = case assert instr.ch(channel).source_current_limit == case @pytest.mark.parametrize("channel", CHANNELS) @pytest.mark.parametrize("case", SOURCE_CURRENT_LIMIT_TYPES) def test_source_current_limit_type(self, instr, channel, case): assert instr.ch(channel).source_current_limit_type == 'limit' instr.ch(channel).source_current_limit_type = case assert instr.ch(channel).source_current_limit_type == case @pytest.mark.parametrize("channel", CHANNELS) def test_source_current_limit_enabled(self, instr, channel): assert not instr.ch(channel).source_current_limit_enabled assert isinstance(instr.ch(channel).source_current_limit_enabled, bool) @pytest.mark.parametrize("sense_mode", SENSE_MODES) @pytest.mark.parametrize("average_count", AVERAGE_COUNTS) @pytest.mark.parametrize("channel", CHANNELS) def test_reading(self, instr, sense_mode, average_count, channel): instr.ch(channel).sense_mode = sense_mode instr.ch(channel).average_count = average_count time.sleep(0.1) assert type(instr.ch(channel).reading) == float @pytest.mark.parametrize("sense_mode", SENSE_MODES) @pytest.mark.parametrize("average_count", AVERAGE_COUNTS) @pytest.mark.parametrize("channel", CHANNELS) def test_readings(self, instr, sense_mode, average_count, channel): instr.ch(channel).sense_mode = sense_mode instr.ch(channel).average_count = average_count time.sleep(0.2) readings = instr.ch(channel).readings assert type(readings) == list assert len(readings) == average_count assert type(readings[0]) == float @pytest.mark.parametrize("average_count", AVERAGE_COUNTS) @pytest.mark.parametrize("channel", CHANNELS) def test_measured_voltage(self, instr, average_count, channel): instr.ch(channel).average_count = average_count time.sleep(0.1) assert type(instr.ch(channel).measured_voltage) == float assert instr.ch(channel).sense_mode == 'voltage' @pytest.mark.parametrize("average_count", AVERAGE_COUNTS) @pytest.mark.parametrize("channel", CHANNELS) def test_measured_voltages(self, instr, average_count, channel): instr.ch(channel).average_count = average_count time.sleep(0.2) measured_voltages = instr.ch(channel).measured_voltages assert type(measured_voltages) == list assert len(measured_voltages) == average_count assert type(measured_voltages[0]) == float assert instr.ch(channel).sense_mode == 'voltage' @pytest.mark.parametrize("average_count", AVERAGE_COUNTS) @pytest.mark.parametrize("channel", CHANNELS) def test_measured_current(self, instr, average_count, channel): instr.ch(channel).average_count = average_count time.sleep(0.1) assert type(instr.ch(channel).measured_current) == float assert instr.ch(channel).sense_mode == 'current' @pytest.mark.parametrize("average_count", AVERAGE_COUNTS) @pytest.mark.parametrize("channel", CHANNELS) def test_measured_currents(self, instr, average_count, channel): instr.ch(channel).average_count = average_count time.sleep(0.2) measured_currents = instr.ch(channel).measured_currents assert type(measured_currents) == list assert len(measured_currents) == average_count assert type(measured_currents[0]) == float assert instr.ch(channel).sense_mode == 'current' @pytest.mark.parametrize("average_count", AVERAGE_COUNTS) @pytest.mark.parametrize("channel", CHANNELS) def test_dvm_voltage(self, instr, average_count, channel): instr.ch(channel).average_count = average_count time.sleep(0.1) assert type(instr.ch(channel).dvm_voltage) == float assert instr.ch(channel).sense_mode == 'dvm' @pytest.mark.parametrize("average_count", AVERAGE_COUNTS) @pytest.mark.parametrize("channel", CHANNELS) def test_dvm_voltages(self, instr, average_count, channel): instr.ch(channel).average_count = average_count time.sleep(0.2) dvm_voltages = instr.ch(channel).dvm_voltages assert type(dvm_voltages) == list assert len(dvm_voltages) == average_count assert type(dvm_voltages[0]) == float assert instr.ch(channel).sense_mode == 'dvm'