def test_when_pressed_moved_released():
mbd = MockBlueDot()
mbd.mock_client_connected()
#when_pressed
event_pressed = Event()
mbd.when_pressed = lambda: event_pressed.set()
#when_double_pressed
event_double_pressed = Event()
mbd.when_double_pressed = lambda: event_double_pressed.set()
#when_moved
event_moved = Event()
mbd.when_moved = lambda: event_moved.set()
#when_released
event_released = Event()
mbd.when_released = lambda: event_released.set()
assert not event_pressed.is_set()
mbd.mock_blue_dot_pressed(0, 0)
assert event_pressed.is_set()
assert not event_moved.is_set()
mbd.mock_blue_dot_moved(1, 1)
assert event_moved.is_set()
assert not event_released.is_set()
mbd.mock_blue_dot_released(0, 0)
assert event_released.is_set()
assert not event_double_pressed.is_set()
mbd.mock_blue_dot_pressed(0, 0)
assert event_double_pressed.is_set()
def test_pressed_moved_released():
mbd = MockBlueDot()
mbd.mock_client_connected()
#initial value
assert not mbd.is_pressed
assert mbd.value == 0
#pressed
mbd.mock_blue_dot_pressed(0, 0)
assert mbd.is_pressed
assert mbd.value == 1
#released
mbd.mock_blue_dot_released(0, 0)
assert not mbd.is_pressed
assert mbd.value == 0
#wait_for_press
delay_function(lambda: mbd.mock_blue_dot_pressed(0, 0), 0.5)
assert mbd.wait_for_press(1)
assert not mbd.wait_for_release(0)
#wait_for_release
delay_function(lambda: mbd.mock_blue_dot_released(0, 0), 0.5)
assert mbd.wait_for_release(1)
assert not mbd.wait_for_press(0)
def test_callback_in_class():
class CallbackClass():
def __init__(self):
self.event = Event()
def no_pos(self):
self.event.set()
self.pos = None
def with_pos(self, pos):
self.event.set()
self.pos = pos
cc = CallbackClass()
mbd = MockBlueDot()
mbd.mock_client_connected()
mbd.when_pressed = cc.no_pos
mbd.mock_blue_dot_pressed(0, 0, 0, 0)
assert cc.event.is_set()
assert cc.pos is None
mbd.mock_blue_dot_released(0, 0, 0, 0)
cc.event.clear()
mbd.when_pressed = cc.with_pos
mbd.mock_blue_dot_pressed(0, 0, 0, 0)
assert cc.event.is_set()
assert cc.pos.middle
def test_swipe():
mbd = MockBlueDot()
mbd.mock_client_connected()
#when_swiped
event_swiped = Event()
mbd.when_swiped = lambda: event_swiped.set()
assert not event_swiped.is_set()
#simulate swipe left to right
mbd.mock_blue_dot_pressed(-1, 0)
mbd.mock_blue_dot_moved(0, 0)
mbd.mock_blue_dot_released(1, 0)
#check event
assert event_swiped.is_set()
#get the swipe
swipe = BlueDotSwipe(mbd.interaction)
assert swipe.right
assert not swipe.left
assert not swipe.up
assert not swipe.down
#right to left
event_swiped.clear()
mbd.mock_blue_dot_pressed(1, 0)
mbd.mock_blue_dot_moved(0, 0)
mbd.mock_blue_dot_released(-1, 0)
assert event_swiped.is_set()
swipe = BlueDotSwipe(mbd.interaction)
assert not swipe.right
assert swipe.left
assert not swipe.up
assert not swipe.down
#bottom to top
event_swiped.clear()
mbd.mock_blue_dot_pressed(0, -1)
mbd.mock_blue_dot_moved(0, 0)
mbd.mock_blue_dot_released(0, 1)
assert event_swiped.is_set()
swipe = BlueDotSwipe(mbd.interaction)
assert not swipe.right
assert not swipe.left
assert swipe.up
assert not swipe.down
#top to bottom
event_swiped.clear()
mbd.mock_blue_dot_pressed(0, 1)
mbd.mock_blue_dot_moved(0, 0)
mbd.mock_blue_dot_released(0, -1)
assert event_swiped.is_set()
swipe = BlueDotSwipe(mbd.interaction)
assert not swipe.right
assert not swipe.left
assert not swipe.up
assert swipe.down
def test_position():
mbd = MockBlueDot()
mbd.mock_client_connected()
mbd.mock_blue_dot_pressed(0, 0)
assert not mbd.position.top
assert mbd.position.middle
assert not mbd.position.bottom
assert not mbd.position.left
assert not mbd.position.right
mbd.mock_blue_dot_moved(1, 0)
assert not mbd.position.top
assert not mbd.position.middle
assert not mbd.position.bottom
assert not mbd.position.left
assert mbd.position.right
mbd.mock_blue_dot_moved(-1, 0)
assert not mbd.position.top
assert not mbd.position.middle
assert not mbd.position.bottom
assert mbd.position.left
assert not mbd.position.right
mbd.mock_blue_dot_moved(0, 1)
assert mbd.position.top
assert not mbd.position.middle
assert not mbd.position.bottom
assert not mbd.position.left
assert not mbd.position.right
mbd.mock_blue_dot_moved(0, -1)
assert not mbd.position.top
assert not mbd.position.middle
assert mbd.position.bottom
assert not mbd.position.left
assert not mbd.position.right
mbd.mock_blue_dot_moved(0.1234, -0.4567)
assert mbd.position.x == 0.1234
assert mbd.position.y == -0.4567
mbd.mock_blue_dot_moved(1, 0)
assert mbd.position.distance == 1
assert mbd.position.angle == 90
def test_rotation():
mbd = MockBlueDot()
mbd.mock_client_connected()
event_rotated = Event()
mbd.when_rotated = lambda: event_rotated.set()
assert not event_rotated.is_set()
#press the blue dot, no rotation
mbd.mock_blue_dot_pressed(-0.1, 1)
assert not event_rotated.is_set()
r = BlueDotRotation(mbd.interaction, mbd.rotation_segments)
assert not r.valid
assert r.value == 0
assert not r.clockwise
assert not r.anti_clockwise
#rotate clockwise
event_rotated.clear()
mbd.mock_blue_dot_moved(0.1, 1)
assert event_rotated.is_set()
r = BlueDotRotation(mbd.interaction, mbd.rotation_segments)
assert r.value == 1
assert r.valid
assert r.clockwise
assert not r.anti_clockwise
#rotate anti-clockwise
event_rotated.clear()
mbd.mock_blue_dot_moved(-0.1, 1)
assert event_rotated.is_set()
r = BlueDotRotation(mbd.interaction, mbd.rotation_segments)
assert r.value == -1
assert r.valid
assert not r.clockwise
assert r.anti_clockwise
# background
# rotate clockwise again
event_rotated.clear()
mbd.set_when_rotated(lambda: delay_function(event_rotated.set, 0.2),
background=True)
mbd.mock_blue_dot_moved(0.1, 1)
assert not event_rotated.is_set()
assert event_rotated.wait(1)
def test_interaction():
mbd = MockBlueDot()
mbd.mock_client_connected()
assert mbd.interaction == None
mbd.mock_blue_dot_pressed(-1, 0)
assert mbd.interaction.active
assert len(mbd.interaction.positions) == 1
assert mbd.interaction.distance == 0
assert mbd.interaction.pressed_position.x == -1
assert mbd.interaction.pressed_position.y == 0
assert mbd.interaction.current_position.x == -1
assert mbd.interaction.current_position.y == 0
assert mbd.interaction.previous_position == None
assert mbd.interaction.released_position == None
mbd.mock_blue_dot_moved(0, 0)
assert mbd.interaction.active
assert len(mbd.interaction.positions) == 2
assert mbd.interaction.distance == 1
assert mbd.interaction.pressed_position.x == -1
assert mbd.interaction.pressed_position.y == 0
assert mbd.interaction.current_position.x == 0
assert mbd.interaction.current_position.y == 0
assert mbd.interaction.previous_position.x == -1
assert mbd.interaction.previous_position.y == 0
assert mbd.interaction.released_position == None
mbd.mock_blue_dot_released(1, 0)
assert not mbd.interaction.active
assert len(mbd.interaction.positions) == 3
assert mbd.interaction.distance == 2
assert mbd.interaction.pressed_position.x == -1
assert mbd.interaction.pressed_position.y == 0
assert mbd.interaction.current_position.x == 1
assert mbd.interaction.current_position.y == 0
assert mbd.interaction.previous_position.x == 0
assert mbd.interaction.previous_position.y == 0
assert mbd.interaction.released_position.x == 1
assert mbd.interaction.released_position.y == 0
def test_when_pressed_moved_released_background():
mbd = MockBlueDot()
mbd.mock_client_connected()
#when_pressed
event_pressed = Event()
mbd.set_when_pressed(lambda: delay_function(event_pressed.set, 0.2),
background=True)
#when_double_pressed
event_double_pressed = Event()
mbd.set_when_double_pressed(
lambda: delay_function(event_double_pressed.set, 0.2), background=True)
#when_moved
event_moved = Event()
mbd.set_when_moved(lambda: delay_function(event_moved.set, 0.2),
background=True)
#when_released
event_released = Event()
mbd.set_when_released(lambda: delay_function(event_released.set, 0.2),
background=True)
# test that the events dont block
assert not event_pressed.is_set()
mbd.mock_blue_dot_pressed(0, 0)
assert not event_pressed.is_set()
assert event_pressed.wait(1)
assert not event_moved.is_set()
mbd.mock_blue_dot_moved(1, 1)
assert not event_moved.is_set()
assert event_moved.wait(1)
assert not event_released.is_set()
mbd.mock_blue_dot_released(0, 0)
assert not event_released.is_set()
assert event_released.wait(1)
# set pressed, moved, released to None so they dont wait
mbd.set_when_pressed(None)
mbd.set_when_moved(None)
mbd.set_when_released(None)
mbd.mock_blue_dot_pressed(0, 0)
mbd.mock_blue_dot_moved(1, 1)
mbd.mock_blue_dot_released(0, 0)
assert not event_double_pressed.is_set()
mbd.mock_blue_dot_pressed(0, 0)
assert not event_double_pressed.is_set()
assert event_double_pressed.wait(1)
from bluedot import MockBlueDot
def say_hello():
print("Hello World")
bd = MockBlueDot()
bd.when_pressed = say_hello
bd.mock_client_connected()
bd.mock_blue_dot_pressed(0,0)
