testing fixture parametrization (4da754a7) · Commits · Marek Vrbka / EmTest

conftest.py

+3 −1

Original line number	Original line	Diff line number	Diff line
	@@ -12,6 +12,8 @@ def emtest_session() -> EmTest:


	@pytest.fixture		@pytest.fixture
	def emtest(emtest_session: EmTest) -> EmTest:		def emtest(request: pytest.FixtureRequest, emtest_session: EmTest) -> EmTest:
			if request.param and request.param is bool:
			emtest_session.multiplexer.inverted = request.param
	emtest_session.setup_method("empty")		emtest_session.setup_method("empty")
	return emtest_session		return emtest_session

weeks/test_hsv.py

+26 −30

Original line number	Original line	Diff line number	Diff line
	@@ -11,23 +11,19 @@ def rgb_to_hsv_normalized(rgb: (float, float, float)) -> (int, int, int):
	return int(h * 256), int(s * 256), int(v * 256)		return int(h * 256), int(s * 256), int(v * 256)


	class TestHSV(EmTest):		def test_hsv_cycle(emtest: EmTest):
	def setup_class(self):
	super().setup_class(self)

	def test_hsv_cycle(self):
	"""		"""
	Effectively, we check if the next RGB value corresponds to higher hue with some rollover protection		Effectively, we check if the next RGB value corresponds to higher hue with some rollover protection
	it will need live testing and we expect that we will need to make adjustments		it will need live testing, and we expect that we will need to make adjustments
	"""		"""
	# Chosen by testing certain amount of values		# Chosen by testing certain amount of values
	sample_count = 4_000		sample_count = 4_000
	blue_hue_value = 165		blue_hue_value = 165
	time.sleep(0.5)		time.sleep(0.5)
	prev_hsv = rgb_to_hsv_normalized(self.leds.get_led_values(sample_count))		prev_hsv = rgb_to_hsv_normalized(emtest.leds.get_led_values(sample_count))
	rollovers = 0		rollovers = 0
	for _ in range(500):		for _ in range(500):
	next_hsv = rgb_to_hsv_normalized(self.leds.get_led_values(sample_count))		next_hsv = rgb_to_hsv_normalized(emtest.leds.get_led_values(sample_count))
	prev_h, _, _ = prev_hsv		prev_h, _, _ = prev_hsv
	next_h, _, _ = next_hsv		next_h, _, _ = next_hsv
	# Rollover protection		# Rollover protection
	@@ -40,5 +36,5 @@ class TestHSV(EmTest):
	assert rollovers >= 4		assert rollovers >= 4

	@pytest.mark.skip(reason="interrupt use not mandatory")		@pytest.mark.skip(reason="interrupt use not mandatory")
	def test_interrupts_used(self):		def test_interrupts_used(emtest: EmTest):
	assert self.interrupts.pit.has_any_interrupt_set()		assert emtest.interrupts.pit.has_any_interrupt_set()

weeks/test_i2c.py

+20 −22

Original line number	Original line	Diff line number	Diff line
	@@ -2,28 +2,26 @@ from emtest import EmTest
	import time		import time


	class TestI2C(EmTest):		def test_gpio_interrupts_used(emtest: EmTest):
	def setup_class(self):		emtest.session.target.halt()
	super().setup_class(self)		assert emtest.interrupts.gpio.has_any_interrupt_set()

	def test_gpio_interrupts_used(self):
	self.session.target.halt()
	assert self.interrupts.gpio.has_any_interrupt_set()

	def test_nothing_printed(self):		def test_nothing_printed(emtest: EmTest):
	time.sleep(2)		time.sleep(2)
	data_ready = self.serial.in_waiting		data_ready = emtest.serial.in_waiting
	time.sleep(30)		time.sleep(30)
	assert self.serial.in_waiting == data_ready		assert emtest.serial.in_waiting == data_ready

	def test_servo_orientation(self):
			def test_servo_orientation(emtest: EmTest):
	time.sleep(5)		time.sleep(5)
	self.serial.flushInput()		emtest.serial.flushInput()
	assert self.serial.in_waiting == 0		assert emtest.serial.in_waiting == 0
	self.servo.set_servo_angle(0)		emtest.servo.set_servo_angle(0)
	time.sleep(10)		time.sleep(10)
	assert self.serial.in_waiting != 0		assert emtest.serial.in_waiting != 0
	previous_serial = self.serial.in_waiting		previous_serial = emtest.serial.in_waiting
	self.servo.set_servo_angle(90)		emtest.servo.set_servo_angle(90)
	time.sleep(5)		time.sleep(5)
	assert self.serial.in_waiting != previous_serial		assert emtest.serial.in_waiting != previous_serial

weeks/test_interrupt.py

+29 −30

Original line number	Original line	Diff line number	Diff line
	@@ -3,33 +3,32 @@ import time
	import vtable_constants		import vtable_constants


	class TestInterrupt(EmTest):		def test_nothing_printed_on_idle(emtest: EmTest):
	def setup_class(self):		emtest.buttons.sw3.off()
	super().setup_class(self)

	def test_nothing_printed_on_idle(self):
	self.buttons.sw3.off()
	time.sleep(5)		time.sleep(5)
	data = self.serial.read(self.serial.in_waiting)		data = emtest.serial.read(emtest.serial.in_waiting)
	assert len(data) == 0		assert len(data) == 0

	def test_full_press(self):
	self.buttons.sw3.off()		def test_full_press(emtest: EmTest):
			emtest.buttons.sw3.off()
	time.sleep(1)		time.sleep(1)
	self.buttons.sw3.on()		emtest.buttons.sw3.on()
	time.sleep(1)		time.sleep(1)
	data = self.serial.read(self.serial.in_waiting)		data = emtest.serial.read(emtest.serial.in_waiting)
	assert len(data) != 0		assert len(data) != 0

	def test_pulse(self):
	self.buttons.sw3.off()		def test_pulse(emtest: EmTest):
			emtest.buttons.sw3.off()
	time.sleep(1)		time.sleep(1)
	self.buttons.sw3.pulse()		emtest.buttons.sw3.pulse()
	time.sleep(0.5)		time.sleep(0.5)
	data = self.serial.read(self.serial.in_waiting)		data = emtest.serial.read(emtest.serial.in_waiting)
	assert len(data) == 0		assert len(data) == 0

	def test_interrupts_used(self):
	self.session.target.halt()		def test_interrupts_used(emtest: EmTest):
	assert self.interrupts.pit.has_any_interrupt_set()		emtest.session.target.halt()
	assert self.interrupts.gpio.interrupt_not_default(vtable_constants.PORT_A_VECTOR)		assert emtest.interrupts.pit.has_any_interrupt_set()
			assert emtest.interrupts.gpio.interrupt_not_default(vtable_constants.PORT_A_VECTOR)

weeks/test_lcd.py

+35 −33

Original line number	Original line	Diff line number	Diff line
			from typing import List

			import pytest

	from emtest import EmTest		from emtest import EmTest
	import time		import time
	from lcd import LCDInterpreter		from lcd import LCDInterpreter
	from lcd import LCDRawPacket		from lcd import LCDRawPacket
	import lcd		import lcd

	def seek_start(packets: [LCDRawPacket]):
			def seek_start(packets: List[LCDRawPacket]):
	# Note: if this raised an error, your submission is possibly wrong		# Note: if this raised an error, your submission is possibly wrong
	first, second, third, fourth = packets[0], packets[1], packets[2], packets[3]		first, second, third, fourth = packets[0], packets[1], packets[2], packets[3]
	while first.data != 0b0011 or second.data != 0b0011 or third.data != 0b0011 or fourth.data != 0b0010:		while first.data != 0b0011 or second.data != 0b0011 or third.data != 0b0011 or fourth.data != 0b0010:
	_, *packets = packets		_, *packets = packets
	first, second, third, fourth = packets[0], packets[1], packets[2], packets[3]		first, second, third, fourth = packets[0], packets[1], packets[2], packets[3]

	class TestLCD(EmTest):
	def setup_class(self):
	super().setup_class(self)
	self.multiplexer.inverted = True

	def test_proper_initialization(self):		@pytest.mark.parametrize("emtest", [True], indirect=True)
			def test_proper_initialization(emtest: EmTest):
	"""		"""
	Proper initialization basically checks if the LCD is initialized as the library students should use		Proper initialization basically checks if the LCD is initialized as the library students should use
	does it, there are actually more ways to do it and some actions can be done in different order		does it, there are actually more ways to do it and some actions can be done in different order
	"""		"""
	self.session.target.reset_and_halt()		emtest.session.target.reset_and_halt()
	self.lcd.start_spying()		emtest.lcd.start_spying()
	self.session.target.resume()		emtest.session.target.resume()
	time.sleep(1)		time.sleep(1)
	packets = self.lcd.finish_spying()		packets = emtest.lcd.finish_spying()
	for packet in packets:		for packet in packets:
	print(packet)		print(packet)
	seek_start(packets)		seek_start(packets)

Admin message