testing fixture parametrization

conftest.py

@@ -12,6 +12,8 @@ def emtest_session() -> EmTest:
 
 
 @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")
     return emtest_session

weeks/test_hsv.py

@@ -11,34 +11,30 @@ def rgb_to_hsv_normalized(rgb: (float, float, float)) -> (int, int, int):
     return int(h * 256), int(s * 256), int(v * 256)
 
 
-class TestHSV(EmTest):
-    def setup_class(self):
-        super().setup_class(self)
+def test_hsv_cycle(emtest: EmTest):
+    """
+    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
+    """
+    # Chosen by testing certain amount of values
+    sample_count = 4_000
+    blue_hue_value = 165
+    time.sleep(0.5)
+    prev_hsv = rgb_to_hsv_normalized(emtest.leds.get_led_values(sample_count))
+    rollovers = 0
+    for _ in range(500):
+        next_hsv = rgb_to_hsv_normalized(emtest.leds.get_led_values(sample_count))
+        prev_h, _, _ = prev_hsv
+        next_h, _, _ = next_hsv
+        # Rollover protection
+        if next_h <= 80 and prev_h > next_h and prev_h >= blue_hue_value:
+            rollovers += 1
+        else:
+            assert prev_h - 80 <= next_h
+        prev_hsv = next_hsv
+    # We expect at least four rollovers
+    assert rollovers >= 4
 
-    def test_hsv_cycle(self):
-        """
-        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
-        """
-        # Chosen by testing certain amount of values
-        sample_count = 4_000
-        blue_hue_value = 165
-        time.sleep(0.5)
-        prev_hsv = rgb_to_hsv_normalized(self.leds.get_led_values(sample_count))
-        rollovers = 0
-        for _ in range(500):
-            next_hsv = rgb_to_hsv_normalized(self.leds.get_led_values(sample_count))
-            prev_h, _, _ = prev_hsv
-            next_h, _, _ = next_hsv
-            # Rollover protection
-            if next_h <= 80 and prev_h > next_h and prev_h >= blue_hue_value:
-                rollovers += 1
-            else:
-                assert prev_h - 80 <= next_h
-            prev_hsv = next_hsv
-        # We expect at least four rollovers
-        assert rollovers >= 4
-
-    @pytest.mark.skip(reason="interrupt use not mandatory")
-    def test_interrupts_used(self):
-        assert self.interrupts.pit.has_any_interrupt_set()
+@pytest.mark.skip(reason="interrupt use not mandatory")
+def test_interrupts_used(emtest: EmTest):
+    assert emtest.interrupts.pit.has_any_interrupt_set()

weeks/test_i2c.py

@@ -2,28 +2,26 @@ from emtest import EmTest
 import time
 
 
-class TestI2C(EmTest):
-    def setup_class(self):
-        super().setup_class(self)
+def test_gpio_interrupts_used(emtest: EmTest):
+    emtest.session.target.halt()
+    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):
-        time.sleep(2)
-        data_ready = self.serial.in_waiting
-        time.sleep(30)
-        assert self.serial.in_waiting == data_ready
+def test_nothing_printed(emtest: EmTest):
+    time.sleep(2)
+    data_ready = emtest.serial.in_waiting
+    time.sleep(30)
+    assert emtest.serial.in_waiting == data_ready
 
-    def test_servo_orientation(self):
-        time.sleep(5)
-        self.serial.flushInput()
-        assert self.serial.in_waiting == 0
-        self.servo.set_servo_angle(0)
-        time.sleep(10)
-        assert self.serial.in_waiting != 0
-        previous_serial = self.serial.in_waiting
-        self.servo.set_servo_angle(90)
-        time.sleep(5)
-        assert self.serial.in_waiting != previous_serial
+
+def test_servo_orientation(emtest: EmTest):
+    time.sleep(5)
+    emtest.serial.flushInput()
+    assert emtest.serial.in_waiting == 0
+    emtest.servo.set_servo_angle(0)
+    time.sleep(10)
+    assert emtest.serial.in_waiting != 0
+    previous_serial = emtest.serial.in_waiting
+    emtest.servo.set_servo_angle(90)
+    time.sleep(5)
+    assert emtest.serial.in_waiting != previous_serial

weeks/test_interrupt.py

@@ -3,33 +3,32 @@ import time
 import vtable_constants
 
 
-class TestInterrupt(EmTest):
-    def setup_class(self):
-        super().setup_class(self)
-
-    def test_nothing_printed_on_idle(self):
-        self.buttons.sw3.off()
-        time.sleep(5)
-        data = self.serial.read(self.serial.in_waiting)
-        assert len(data) == 0
-
-    def test_full_press(self):
-        self.buttons.sw3.off()
-        time.sleep(1)
-        self.buttons.sw3.on()
-        time.sleep(1)
-        data = self.serial.read(self.serial.in_waiting)
-        assert len(data) != 0
-
-    def test_pulse(self):
-        self.buttons.sw3.off()
-        time.sleep(1)
-        self.buttons.sw3.pulse()
-        time.sleep(0.5)
-        data = self.serial.read(self.serial.in_waiting)
-        assert len(data) == 0
-
-    def test_interrupts_used(self):
-        self.session.target.halt()
-        assert self.interrupts.pit.has_any_interrupt_set()
-        assert self.interrupts.gpio.interrupt_not_default(vtable_constants.PORT_A_VECTOR)
+def test_nothing_printed_on_idle(emtest: EmTest):
+    emtest.buttons.sw3.off()
+    time.sleep(5)
+    data = emtest.serial.read(emtest.serial.in_waiting)
+    assert len(data) == 0
+
+
+def test_full_press(emtest: EmTest):
+    emtest.buttons.sw3.off()
+    time.sleep(1)
+    emtest.buttons.sw3.on()
+    time.sleep(1)
+    data = emtest.serial.read(emtest.serial.in_waiting)
+    assert len(data) != 0
+
+
+def test_pulse(emtest: EmTest):
+    emtest.buttons.sw3.off()
+    time.sleep(1)
+    emtest.buttons.sw3.pulse()
+    time.sleep(0.5)
+    data = emtest.serial.read(emtest.serial.in_waiting)
+    assert len(data) == 0
+
+
+def test_interrupts_used(emtest: EmTest):
+    emtest.session.target.halt()
+    assert emtest.interrupts.pit.has_any_interrupt_set()
+    assert emtest.interrupts.gpio.interrupt_not_default(vtable_constants.PORT_A_VECTOR)

weeks/test_lcd.py

+from typing import List
+
+import pytest
+
 from emtest import EmTest
 import time
 from lcd import LCDInterpreter
 from lcd import LCDRawPacket
 import lcd
 
-def seek_start(packets: [LCDRawPacket]):
+
+def seek_start(packets: List[LCDRawPacket]):
     # Note: if this raised an error, your submission is possibly wrong
     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:
         _, *packets = packets
         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):
-        """
-        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
-        """
-        self.session.target.reset_and_halt()
-        self.lcd.start_spying()
-        self.session.target.resume()
-        time.sleep(1)
-        packets = self.lcd.finish_spying()
-        for packet in packets:
-            print(packet)
-        seek_start(packets)
-        messages = lcd.packets_to_messages(packets)
-        assert len(messages) >= 5
-        # Initial startup commands
-        for message in messages[:5]:
-            assert message.rs is False
-            assert message.rw is False
-        # Two startup commands
-        assert messages[0].data == 0b0011_0011
-        assert messages[1].data == 0b0011_0010
-        # Interface data length command
-        assert (messages[2].data & 0b1111_1100) == 0b0010_1100
-        # Set display on, cursor and blinking off
-        assert messages[3].data == 0b0000_1100
-        # Clear display
-        assert messages[4].data == 0b0000_0001
+@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
+    does it, there are actually more ways to do it and some actions can be done in different order
+    """
+    emtest.session.target.reset_and_halt()
+    emtest.lcd.start_spying()
+    emtest.session.target.resume()
+    time.sleep(1)
+    packets = emtest.lcd.finish_spying()
+    for packet in packets:
+        print(packet)
+    seek_start(packets)
+    messages = lcd.packets_to_messages(packets)
+    assert len(messages) >= 5
+    # Initial startup commands
+    for message in messages[:5]:
+        assert message.rs is False
+        assert message.rw is False
+    # Two startup commands
+    assert messages[0].data == 0b0011_0011
+    assert messages[1].data == 0b0011_0010
+    # Interface data length command
+    assert (messages[2].data & 0b1111_1100) == 0b0010_1100
+    # Set display on, cursor and blinking off
+    assert messages[3].data == 0b0000_1100
+    # Clear display
+    assert messages[4].data == 0b0000_0001
 
     def test_any_text_sent(self):
         self.session.target.reset_and_halt()