def test_output_blink_interrupt_on():
pin = MockPin(2)
device = DigitalOutputDevice(pin)
device.blink(1, 0.1)
sleep(0.2)
device.off() # should interrupt while on
pin.assert_states([False, True, False])
def test_input_is_active():
pin = MockPin(2)
with InputDevice(pin, pull_up=True) as device:
pin.drive_high()
assert not device.is_active
pin.drive_low()
assert device.is_active
def test_output_blink_interrupt_off():
pin = MockPin(2)
with DigitalOutputDevice(pin) as device:
device.blink(0.1, 1)
sleep(0.2)
device.off() # should interrupt while off
pin.assert_states([False, True, False])
def test_input_event_activated():
event = Event()
pin = MockPin(2)
with DigitalInputDevice(pin) as device:
device.when_activated = lambda: event.set()
assert not event.is_set()
pin.drive_high()
assert event.is_set()
def test_mock_pin_pull():
pin = MockPin(2)
pin.function = "input"
assert pin.pull == "floating"
pin.pull = "up"
assert pin.state
pin.pull = "down"
assert not pin.state
def test_mock_pin_pull():
pin = MockPin(4)
pin.function = 'input'
assert pin.pull == 'floating'
pin.pull = 'up'
assert pin.state
pin.pull = 'down'
assert not pin.state
def test_input_line_sensor():
pin = MockPin(2)
with LineSensor(pin) as sensor:
pin.drive_low() # logic is inverted for line sensor
assert sensor.wait_for_line(1)
assert sensor.line_detected
pin.drive_high()
assert sensor.wait_for_no_line(1)
assert not sensor.line_detected
def test_input_motion_sensor():
pin = MockPin(2)
with MotionSensor(pin) as sensor:
pin.drive_high()
assert sensor.wait_for_motion(1)
assert sensor.motion_detected
pin.drive_low()
assert sensor.wait_for_no_motion(1)
assert not sensor.motion_detected
def test_input_smoothed_values():
pin = MockPin(2)
with SmoothedInputDevice(pin) as device:
device._queue.start()
assert not device.is_active
pin.drive_high()
assert device.wait_for_active(1)
pin.drive_low()
assert device.wait_for_inactive(1)
def test_input_is_active_high():
pin = MockPin(2)
with InputDevice(pin, pull_up=False) as device:
pin.drive_high()
assert device.is_active
assert repr(device) == '<gpiozero.InputDevice object on pin MOCK2, pull_up=False, is_active=True>'
pin.drive_low()
assert not device.is_active
assert repr(device) == '<gpiozero.InputDevice object on pin MOCK2, pull_up=False, is_active=False>'
def test_output_blink_foreground():
pin = MockPin(2)
device = DigitalOutputDevice(pin)
device.blink(0.1, 0.1, n=2, background=False)
pin.assert_states_and_times([
(0.0, False),
(0.0, True),
(0.1, False),
(0.1, True),
(0.1, False)
])
def test_input_button():
pin = MockPin(2)
with Button(pin) as button:
assert pin.pull == 'up'
assert not button.is_pressed
pin.drive_low()
assert button.is_pressed
assert button.wait_for_press(1)
pin.drive_high()
assert not button.is_pressed
assert button.wait_for_release(1)
def test_output_blink_background():
pin = MockPin(2)
device = DigitalOutputDevice(pin)
device.blink(0.1, 0.1, n=2)
device._blink_thread.join() # naughty, but ensures no arbitrary waits in the test
pin.assert_states_and_times([
(0.0, False),
(0.0, True),
(0.1, False),
(0.1, True),
(0.1, False)
])
def test_output_blink_foreground():
pin = MockPin(2)
with DigitalOutputDevice(pin) as device:
start = time()
device.blink(0.1, 0.1, n=2, background=False)
assert isclose(time() - start, 0.4, abs_tol=0.05)
pin.assert_states_and_times([
(0.0, False),
(0.0, True),
(0.1, False),
(0.1, True),
(0.1, False)
])
def test_input_partial_callback():
event = Event()
pin = MockPin(2)
def foo(a, b):
event.set()
return a + b
bar = partial(foo, 1)
baz = partial(bar, 2)
with DigitalInputDevice(pin) as device:
device.when_activated = baz
assert not event.is_set()
pin.drive_high()
assert event.is_set()
def test_led_bar_graph_value():
pin1 = MockPin(2)
pin2 = MockPin(3)
pin3 = MockPin(4)
with LEDBarGraph(pin1, pin2, pin3) as graph:
assert isinstance(graph[0], LED)
assert isinstance(graph[1], LED)
assert isinstance(graph[2], LED)
assert graph.active_high
assert graph[0].active_high
assert graph[1].active_high
assert graph[2].active_high
graph.value = 0
assert graph.value == 0
assert not any((pin1.state, pin2.state, pin3.state))
graph.value = 1
assert graph.value == 1
assert all((pin1.state, pin2.state, pin3.state))
graph.value = 1/3
assert graph.value == 1/3
assert pin1.state and not (pin2.state or pin3.state)
graph.value = -1/3
assert graph.value == -1/3
assert pin3.state and not (pin1.state or pin2.state)
pin1.state = True
pin2.state = True
assert graph.value == 1
pin3.state = False
assert graph.value == 2/3
pin3.state = True
pin1.state = False
assert graph.value == -2/3
def test_led_board_blink_interrupt_off():
pin1 = MockPin(2)
pin2 = MockPin(3)
pin3 = MockPin(4)
with LEDBoard(pin1, LEDBoard(pin2, pin3)) as board:
board.blink(0.1, 1)
sleep(0.2)
board.off() # should interrupt while off
pin1.assert_states([False, True, False])
pin2.assert_states([False, True, False])
pin3.assert_states([False, True, False])
def test_output_blink_background():
pin = MockPin(2)
with DigitalOutputDevice(pin) as device:
start = time()
device.blink(0.1, 0.1, n=2)
assert isclose(time() - start, 0, abs_tol=0.05)
device._blink_thread.join() # naughty, but ensures no arbitrary waits in the test
assert isclose(time() - start, 0.4, abs_tol=0.05)
pin.assert_states_and_times([
(0.0, False),
(0.0, True),
(0.1, False),
(0.1, True),
(0.1, False)
])
def test_traffic_lights_buzzer():
red_pin = MockPin(2)
amber_pin = MockPin(3)
green_pin = MockPin(4)
buzzer_pin = MockPin(5)
button_pin = MockPin(6)
with TrafficLightsBuzzer(
TrafficLights(red_pin, amber_pin, green_pin),
Buzzer(buzzer_pin),
Button(button_pin)) as board:
board.lights.red.on()
board.buzzer.on()
assert red_pin.state
assert not amber_pin.state
assert not green_pin.state
assert buzzer_pin.state
button_pin.drive_low()
assert board.button.is_active
def test_led_board_blink_foreground():
pin1 = MockPin(2)
pin2 = MockPin(3)
pin3 = MockPin(4)
with LEDBoard(pin1, LEDBoard(pin2, pin3)) as board:
board.blink(0.1, 0.1, n=2, background=False)
test = [
(0.0, False),
(0.0, True),
(0.1, False),
(0.1, True),
(0.1, False)
]
pin1.assert_states_and_times(test)
pin2.assert_states_and_times(test)
pin3.assert_states_and_times(test)
def test_led_board_blink_background():
pin1 = MockPin(2)
pin2 = MockPin(3)
pin3 = MockPin(4)
with LEDBoard(pin1, LEDBoard(pin2, pin3)) as board:
board.blink(0.1, 0.1, n=2)
board._blink_thread.join() # naughty, but ensures no arbitrary waits in the test
test = [
(0.0, False),
(0.0, True),
(0.1, False),
(0.1, True),
(0.1, False)
]
pin1.assert_states_and_times(test)
pin2.assert_states_and_times(test)
pin3.assert_states_and_times(test)
def test_led_board_blink_take_over():
pin1 = MockPin(2)
pin2 = MockPin(3)
pin3 = MockPin(4)
with LEDBoard(pin1, LEDBoard(pin2, pin3)) as board:
board[1].blink(0.1, 0.1, n=2)
board.blink(0.1, 0.1, n=2) # immediately take over blinking
board[1]._blink_thread.join()
board._blink_thread.join()
test = [
(0.0, False),
(0.0, True),
(0.1, False),
(0.1, True),
(0.1, False)
]
pin1.assert_states_and_times(test)
pin2.assert_states_and_times(test)
pin3.assert_states_and_times(test)
def test_led_board_blink_control_all():
pin1 = MockPin(2)
pin2 = MockPin(3)
pin3 = MockPin(4)
with LEDBoard(pin1, LEDBoard(pin2, pin3)) as board:
board.blink(0.1, 0.1, n=2)
# make sure the blink thread's started
while not board._blink_leds:
sleep(0.00001)
board[0].off() # immediately take over all LEDs
board[1][0].off()
board[1][1].off()
board._blink_thread.join() # blink should terminate here anyway
test = [
(0.0, False),
(0.0, True),
(0.0, False),
]
pin1.assert_states_and_times(test)
pin2.assert_states_and_times(test)
pin3.assert_states_and_times(test)
def test_led_board_blink_control():
pin1 = MockPin(2)
pin2 = MockPin(3)
pin3 = MockPin(4)
with LEDBoard(pin1, LEDBoard(pin2, pin3)) as board:
board.blink(0.1, 0.1, n=2)
# make sure the blink thread's started
while not board._blink_leds:
sleep(0.00001)
board[1][0].off() # immediately take over the second LED
board._blink_thread.join() # naughty, but ensures no arbitrary waits in the test
test = [
(0.0, False),
(0.0, True),
(0.1, False),
(0.1, True),
(0.1, False)
]
pin1.assert_states_and_times(test)
pin3.assert_states_and_times(test)
print(pin2.states)
pin2.assert_states_and_times([(0.0, False), (0.0, True), (0.0, False)])
def test_mock_pin_state():
pin = MockPin(2)
with pytest.raises(PinSetInput):
pin.state = 1
pin.function = "output"
assert pin.state == 0
pin.state = 1
assert pin.state == 1
pin.state = 0
assert pin.state == 0
pin.state = 0.5
assert pin.state == 1
def test_led_bar_graph_value():
pin1 = MockPin(2)
pin2 = MockPin(3)
pin3 = MockPin(4)
with LEDBarGraph(pin1, pin2, pin3) as graph:
graph.value = 0
assert not any((pin1.state, pin2.state, pin3.state))
graph.value = 1
assert all((pin1.state, pin2.state, pin3.state))
graph.value = 1/3
assert pin1.state and not (pin2.state or pin3.state)
graph.value = -1/3
assert pin3.state and not (pin1.state or pin2.state)
pin1.state = True
pin2.state = True
assert graph.value == 1
pin3.state = False
assert graph.value == 2/3
pin3.state = True
pin1.state = False
assert graph.value == -2/3
def test_output_write_silly():
pin = MockPin(2)
with OutputDevice(pin) as device:
pin.function = 'input'
with pytest.raises(AttributeError):
device.on()
def test_output_pwm_not_supported():
with pytest.raises(AttributeError):
PWMOutputDevice(MockPin(2))
def test_rgbled_initial_value_nonpwm():
r, g, b = (MockPin(i) for i in (1, 2, 3))
with RGBLED(r, g, b, pwm=False, initial_value=(0, 1, 1)) as device:
assert r.state == 0
assert g.state == 1
assert b.state == 1
def test_output_write_silly():
pin = MockPin(2)
with OutputDevice(pin) as device:
pin.function = 'input'
with pytest.raises(AttributeError):
device.on()
def test_servo_pins_nonpwm():
p = MockPin(2)
with pytest.raises(PinPWMUnsupported):
Servo(p)
def test_led_board_blink_foreground():
pin1 = MockPin(2)
pin2 = MockPin(3)
pin3 = MockPin(4)
with LEDBoard(pin1, LEDBoard(pin2, pin3)) as board:
board.blink(0.1, 0.1, n=2, background=False)
test = [(0.0, False), (0.0, True), (0.1, False), (0.1, True),
(0.1, False)]
pin1.assert_states_and_times(test)
pin2.assert_states_and_times(test)
pin3.assert_states_and_times(test)
def test_led_board_blink_background():
pin1 = MockPin(2)
pin2 = MockPin(3)
pin3 = MockPin(4)
with LEDBoard(pin1, LEDBoard(pin2, pin3)) as board:
board.blink(0.1, 0.1, n=2)
board._blink_thread.join(
) # naughty, but ensures no arbitrary waits in the test
test = [(0.0, False), (0.0, True), (0.1, False), (0.1, True),
(0.1, False)]
pin1.assert_states_and_times(test)
pin2.assert_states_and_times(test)
pin3.assert_states_and_times(test)
def test_pi_liter():
pins = [MockPin(n) for n in (4, 17, 27, 18, 22, 23, 24, 25)]
with PiLiter() as board:
assert [device.pin for device in board] == pins
def test_mock_pin_frequency_unsupported():
pin = MockPin(2)
pin.frequency = None
with pytest.raises(PinPWMUnsupported):
pin.frequency = 100
def test_led_bar_graph_value():
pin1 = MockPin(2)
pin2 = MockPin(3)
pin3 = MockPin(4)
with LEDBarGraph(pin1, pin2, pin3) as graph:
assert isinstance(graph[0], LED)
assert isinstance(graph[1], LED)
assert isinstance(graph[2], LED)
assert graph.active_high
assert graph[0].active_high
assert graph[1].active_high
assert graph[2].active_high
graph.value = 0
assert graph.value == 0
assert not any((pin1.state, pin2.state, pin3.state))
graph.value = 1
assert graph.value == 1
assert all((pin1.state, pin2.state, pin3.state))
graph.value = 1 / 3
assert graph.value == 1 / 3
assert pin1.state and not (pin2.state or pin3.state)
graph.value = -1 / 3
assert graph.value == -1 / 3
assert pin3.state and not (pin1.state or pin2.state)
pin1.state = True
pin2.state = True
assert graph.value == 1
pin3.state = False
assert graph.value == 2 / 3
pin3.state = True
pin1.state = False
assert graph.value == -2 / 3
def test_led_board_blink_interrupt_off():
pin1 = MockPin(2)
pin2 = MockPin(3)
pin3 = MockPin(4)
with LEDBoard(pin1, LEDBoard(pin2, pin3)) as board:
board.blink(0.1, 1)
sleep(0.2)
board.off() # should interrupt while off
pin1.assert_states([False, True, False])
pin2.assert_states([False, True, False])
pin3.assert_states([False, True, False])
def test_led_board_blink_control_all():
pin1 = MockPin(2)
pin2 = MockPin(3)
pin3 = MockPin(4)
with LEDBoard(pin1, LEDBoard(pin2, pin3)) as board:
board.blink(0.1, 0.1, n=2)
# make sure the blink thread's started
while not board._blink_leds:
sleep(0.00001) # pragma: no cover
board[0].off() # immediately take over all LEDs
board[1][0].off()
board[1][1].off()
board._blink_thread.join() # blink should terminate here anyway
test = [
(0.0, False),
(0.0, True),
(0.0, False),
]
pin1.assert_states_and_times(test)
pin2.assert_states_and_times(test)
pin3.assert_states_and_times(test)
def test_led_board_blink_take_over():
pin1 = MockPin(2)
pin2 = MockPin(3)
pin3 = MockPin(4)
with LEDBoard(pin1, LEDBoard(pin2, pin3)) as board:
board[1].blink(0.1, 0.1, n=2)
board.blink(0.1, 0.1, n=2) # immediately take over blinking
board[1]._blink_thread.join()
board._blink_thread.join()
test = [(0.0, False), (0.0, True), (0.1, False), (0.1, True),
(0.1, False)]
pin1.assert_states_and_times(test)
pin2.assert_states_and_times(test)
pin3.assert_states_and_times(test)
def test_led_board_blink_control():
pin1 = MockPin(2)
pin2 = MockPin(3)
pin3 = MockPin(4)
with LEDBoard(pin1, LEDBoard(pin2, pin3)) as board:
board.blink(0.1, 0.1, n=2)
# make sure the blink thread's started
while not board._blink_leds:
sleep(0.00001) # pragma: no cover
board[1][0].off() # immediately take over the second LED
board._blink_thread.join(
) # naughty, but ensures no arbitrary waits in the test
test = [(0.0, False), (0.0, True), (0.1, False), (0.1, True),
(0.1, False)]
pin1.assert_states_and_times(test)
pin3.assert_states_and_times(test)
print(pin2.states)
pin2.assert_states_and_times([(0.0, False), (0.0, True), (0.0, False)])
def test_output_blink_foreground():
pin = MockPin(2)
device = DigitalOutputDevice(pin)
device.blink(0.1, 0.1, n=2, background=False)
pin.assert_states_and_times([(0.0, False), (0.0, True), (0.1, False),
(0.1, True), (0.1, False)])
def test_rgbled_initial_bad_value_nonpwm():
r, g, b = (MockPin(i) for i in (1, 2, 3))
with pytest.raises(ValueError):
RGBLED(r, g, b, pwm=False, initial_value=(0.1, 0.2, 0))
def test_snow_pi():
pins = [MockPin(n) for n in (23, 24, 25, 17, 18, 22, 7, 8, 9)]
with SnowPi() as board:
assert [device.pin for device in board.leds] == pins
def test_input_wait_active():
pin = MockPin(2)
with DigitalInputDevice(pin) as device:
pin.drive_high()
assert device.wait_for_active(1)
assert not device.wait_for_inactive(0)
def test_output_write_closed():
device = OutputDevice(MockPin(2))
device.close()
with pytest.raises(GPIODeviceClosed):
device.on()
def test_fish_dish():
pins = [MockPin(n) for n in (9, 22, 4, 8, 7)]
with FishDish() as board:
assert [led.pin for led in board.lights
] + [board.buzzer.pin, board.button.pin] == pins
def test_rgbled_fade_background_nonpwm():
r, g, b = (MockPin(i) for i in (1, 2, 3))
with RGBLED(r, g, b, pwm=False) as device:
with pytest.raises(ValueError):
device.blink(0, 0, 0.2, 0.2, n=2)
def test_traffic_hat():
pins = [MockPin(n) for n in (24, 23, 22, 5, 25)]
with TrafficHat() as board:
assert [led.pin for led in board.lights
] + [board.buzzer.pin, board.button.pin] == pins
def test_rgbled_pulse_foreground_nonpwm():
r, g, b = (MockPin(i) for i in (1, 2, 3))
with RGBLED(r, g, b, pwm=False) as device:
with pytest.raises(ValueError):
device.pulse(0.2, 0.2, n=2, background=False)
def test_mock_pin_frequency_unsupported():
with pytest.raises(AttributeError):
pin = MockPin(3)
pin.frequency = 100
def test_output_pwm_bad_initial_value():
with pytest.raises(ValueError):
PWMOutputDevice(MockPin(2), initial_value=2)
def test_mock_pin_edges():
pin = MockPin(2)
assert pin.when_changed is None
fired = Event()
pin.function = 'input'
pin.edges = 'both'
assert pin.edges == 'both'
pin.drive_low()
assert not pin.state
def changed():
fired.set()
pin.when_changed = changed
pin.drive_high()
assert pin.state
assert fired.wait(0)
fired.clear()
pin.edges = 'falling'
pin.drive_low()
assert not pin.state
assert fired.wait(0)
fired.clear()
pin.drive_high()
assert pin.state
assert not fired.wait(0)
assert pin.edges == 'falling'
def teardown_function(function):
MockPin.clear_pins()
def test_mock_pin_init():
with pytest.raises(TypeError):
MockPin()
with pytest.raises(ValueError):
MockPin(60)
assert MockPin(2).number == 2
def test_mock_pin_edges():
pin = MockPin(5)
assert pin.when_changed is None
fired = Event()
pin.function = 'input'
pin.edges = 'both'
assert pin.edges == 'both'
pin.drive_low()
assert not pin.state
def changed():
fired.set()
pin.when_changed = changed
pin.drive_high()
assert pin.state
assert fired.wait(0)
fired.clear()
pin.edges = 'falling'
pin.drive_low()
assert not pin.state
assert fired.wait(0)
fired.clear()
pin.drive_high()
assert pin.state
assert not fired.wait(0)
assert pin.edges == 'falling'
def test_mock_pin_open_close():
pin = MockPin(2)
pin.close()
def teardown_function(function):
MockPin.clear_pins()
def test_mock_pin_init_twice_same_pin():
pin1 = MockPin(2)
pin2 = MockPin(pin1.number)
assert pin1 is pin2
def test_pi_traffic():
pins = [MockPin(n) for n in (9, 10, 11)]
with PiTraffic() as board:
assert [device.pin for device in board] == pins
def test_mock_pin_init_twice_different_pin():
pin1 = MockPin(2)
pin2 = MockPin(pin1.number+1)
assert pin1 != pin2
assert pin1.number == 2
assert pin2.number == pin1.number+1
