def _onOffSenorTest(onOffClass, loop):
"""Test on/off sensor."""
plm = MockPLM(loop=loop)
address = '1a2b3c'
target = bytearray([0x00, 0x00, 0x01])
cat = 0x10
subcat = 0x00
product_key = 0x00
description = 'Generic Security, Heath and Safety Device'
model = ''
callbacks = MockCallbacks()
device = onOffClass(plm, address, cat, subcat, product_key,
description, model)
plm.devices[address] = device
device.states[0x01].register_updates(callbacks.callbackmethod1)
msg = StandardReceive(
address, target, COMMAND_LIGHT_ON_0X11_NONE, cmd2=0x01,
flags=MessageFlags.create(MESSAGE_TYPE_ALL_LINK_BROADCAST, 0, 3, 3))
plm.message_received(msg)
yield from asyncio.sleep(.1, loop=loop)
assert callbacks.callbackvalue1 == 1
device = onOffClass(plm, address, cat, subcat, product_key,
description, model)
device.states[0x01].register_updates(callbacks.callbackmethod1)
msg = StandardReceive(
address, target, COMMAND_LIGHT_OFF_0X13_0X00,
flags=MessageFlags.create(MESSAGE_TYPE_ALL_LINK_BROADCAST, 0, 3, 3))
plm.message_received(msg)
yield from asyncio.sleep(.1, loop=loop)
assert callbacks.callbackvalue1 == 0
def run_test(loop):
"""Asyncio test run."""
plm = MockPLM(loop)
address = '1a2b3c'
target = '4d5e6f'
cat = 0x07
subcat = 0x00
product_key = 0x00
description = 'I/O Linc'
model = '2450'
callbacks = MockCallbacks()
device = SensorsActuators_2450(plm, address, cat, subcat,
product_key, description, model)
plm.devices[address] = device
assert device.states[0x01].name == 'openClosedRelay'
assert device.states[0x02].name == 'openClosedSensor'
device.states[0x01].register_updates(callbacks.callbackmethod1)
device.states[0x02].register_updates(callbacks.callbackmethod2)
device.async_refresh_state()
yield from asyncio.sleep(.1, loop=loop)
# First state
sentmsg = StandardSend(address, COMMAND_LIGHT_STATUS_REQUEST_0X19_0X00)
assert plm.sentmessage == sentmsg.hex
receivedmsg = StandardSend(address,
COMMAND_LIGHT_STATUS_REQUEST_0X19_0X00,
acknak=MESSAGE_ACK)
plm.message_received(receivedmsg)
yield from asyncio.sleep(.1, loop=loop)
receivedmsg = StandardReceive(
address, target, COMMAND_LIGHT_ON_0X11_NONE, cmd2=0x55,
flags=MessageFlags.create(MESSAGE_TYPE_DIRECT_MESSAGE_ACK, 0))
plm.message_received(receivedmsg)
yield from asyncio.sleep(.3, loop=loop)
assert callbacks.callbackvalue1 == 0xff
# Second state
receivedmsg = StandardSend(address,
COMMAND_LIGHT_STATUS_REQUEST_0X19_0X01,
acknak=MESSAGE_ACK)
plm.message_received(receivedmsg)
yield from asyncio.sleep(.1, loop=loop)
receivedmsg = StandardReceive(
address, target, COMMAND_LIGHT_ON_0X11_NONE, cmd2=0x33,
flags=MessageFlags.create(MESSAGE_TYPE_BROADCAST_MESSAGE, 0))
plm.message_received(receivedmsg)
yield from asyncio.sleep(.1, loop=loop)
sentmsg = StandardSend(address, COMMAND_LIGHT_STATUS_REQUEST_0X19_0X01)
assert plm.sentmessage == sentmsg.hex
assert callbacks.callbackvalue1 == 0xff
assert callbacks.callbackvalue2 == 1
def run_test(loop):
"""Asyncio test method."""
plm = MockPLM(loop)
callbacks = MockCallbacks()
address = '1a2b3c'
cat = 0x02
subcat = 0x0d
product_key = None
description = 'ToggleLinc Relay'
model = '2466S'
device = SwitchedLightingControl_2663_222(
plm, address, cat, subcat, product_key, description, model)
plm.devices[address] = device
assert device.address.hex == address
assert device.cat == cat
assert device.subcat == subcat
assert device.product_key == 0x00 # Product key should not be None
assert device.description == description
assert device.model == model
assert device.id == address
device.states[0x01].register_updates(callbacks.callbackmethod1)
device.states[0x02].register_updates(callbacks.callbackmethod2)
receivedmsg = StandardReceive(
address, '000001', COMMAND_LIGHT_ON_0X11_NONE, cmd2=0x66,
flags=MessageFlags.create(MESSAGE_TYPE_ALL_LINK_BROADCAST,
0, 2, 3))
plm.message_received(receivedmsg)
yield from asyncio.sleep(.1, loop=loop)
assert callbacks.callbackvalue1 == 0xff
receivedmsg = StandardReceive(
address, '000001', COMMAND_LIGHT_OFF_0X13_0X00,
flags=MessageFlags.create(MESSAGE_TYPE_ALL_LINK_BROADCAST,
0, 2, 3))
plm.message_received(receivedmsg)
yield from asyncio.sleep(.1, loop=loop)
assert callbacks.callbackvalue1 == 0x00
receivedmsg = StandardReceive(
address, '000002', COMMAND_LIGHT_ON_0X11_NONE, cmd2=0x66,
flags=MessageFlags.create(MESSAGE_TYPE_ALL_LINK_BROADCAST,
0, 2, 3))
plm.message_received(receivedmsg)
yield from asyncio.sleep(.1, loop=loop)
assert callbacks.callbackvalue2 == 0xff
receivedmsg = StandardReceive(
address, '000002', COMMAND_LIGHT_OFF_0X13_0X00,
flags=MessageFlags.create(MESSAGE_TYPE_ALL_LINK_BROADCAST,
0, 2, 3))
plm.message_received(receivedmsg)
yield from asyncio.sleep(.1, loop=loop)
assert callbacks.callbackvalue2 == 0x00
def run_test(loop):
"""Asyncio test method."""
plm = MockPLM(loop)
address = '1a2b3c'
target = '4d5e6f'
cat = 0x02
subcat = 0x0d
product_key = None
description = 'ToggleLinc Relay'
model = '2466S'
device = SwitchedLightingControl(plm, address, cat, subcat,
product_key, description, model)
plm.devices[address] = device
assert device.address.hex == address
assert device.cat == cat
assert device.subcat == subcat
assert device.product_key == 0x00 # Product key should not be None
assert device.description == description
assert device.model == model
assert device.id == address
callbacks = MockCallbacks()
device.states[0x01].register_updates(callbacks.callbackmethod1)
device.states[0x01].on()
yield from asyncio.sleep(.1, loop=loop)
receivedmsg = StandardSend(address, COMMAND_LIGHT_ON_0X11_NONE,
cmd2=0xff, acknak=MESSAGE_ACK)
plm.message_received(receivedmsg)
yield from asyncio.sleep(.1, loop=loop)
receivedmsg = StandardReceive(
address, target, COMMAND_LIGHT_ON_0X11_NONE, cmd2=0xff,
flags=MessageFlags.create(MESSAGE_TYPE_DIRECT_MESSAGE_ACK,
0, 2, 3))
plm.message_received(receivedmsg)
yield from asyncio.sleep(.1, loop=loop)
sentmsg = StandardSend(address, COMMAND_LIGHT_ON_0X11_NONE, cmd2=0xff)
assert plm.sentmessage == sentmsg.hex
assert callbacks.callbackvalue1 == 0xff
device.states[0x01].off()
yield from asyncio.sleep(.1, loop=loop)
receivedmsg = StandardSend(address, COMMAND_LIGHT_OFF_0X13_0X00,
acknak=MESSAGE_ACK)
plm.message_received(receivedmsg)
yield from asyncio.sleep(.1, loop=loop)
receivedmsg = StandardReceive(
address, target, COMMAND_LIGHT_OFF_0X13_0X00,
flags=MessageFlags.create(MESSAGE_TYPE_DIRECT_MESSAGE_ACK,
0, 2, 3))
plm.message_received(receivedmsg)
yield from asyncio.sleep(.1, loop=loop)
sentmsg = StandardSend(address, COMMAND_LIGHT_OFF_0X13_0X00)
assert plm.sentmessage == sentmsg.hex
assert callbacks.callbackvalue1 == 0x00
def run_test(loop):
"""Asyncio coroutine to actually run the test."""
class sensorState(object):
"""Callback class to caputure sensor value changes."""
sensor = None
def sensor_status_callback(self, device_id, state, value):
"""Callback method to update sensor value."""
self.sensor = value
plm = MockPLM(loop)
address = '1a2b3c'
target = bytearray([0x00, 0x00, 0x01])
cmd2 = 0x01
cat = 0x10
subcat = 0x00
product_key = 0x00
description = 'Generic Security, Heath and Safety Device'
model = ''
callbacks = MockCallbacks()
device = SecurityHealthSafety(plm, address, cat, subcat, product_key,
description, model)
plm.devices[address] = device
device.states[0x01].register_updates(callbacks.callbackmethod1)
msg = StandardReceive(address,
target,
COMMAND_LIGHT_ON_0X11_NONE,
cmd2=cmd2,
flags=MessageFlags.create(
MESSAGE_TYPE_ALL_LINK_BROADCAST, 0, 3, 3))
plm.message_received(msg)
yield from asyncio.sleep(.1, loop=loop)
assert callbacks.callbackvalue1 == cmd2
device = SecurityHealthSafety(plm, address, cat, subcat, product_key,
description, model)
device.states[0x01].register_updates(callbacks.callbackmethod1)
msg = StandardReceive(address,
target,
COMMAND_LIGHT_OFF_0X13_0X00,
flags=MessageFlags.create(
MESSAGE_TYPE_ALL_LINK_BROADCAST, 0, 3, 3))
plm.message_received(msg)
yield from asyncio.sleep(.1, loop=loop)
assert callbacks.callbackvalue1 == 0x00
def run_test(loop):
plm = MockPLM(loop)
address = '1a2b3c'
target = '4d5e6f'
cmd2 = 0x04
cat = 0x10
subcat = 0x00
product_key = 0x00
description = 'Generic Security, Heath and Safety Device'
model = ''
callbacks = MockCallbacks()
device = SecurityHealthSafety_2982_222(plm, address, cat, subcat,
product_key, description, model)
plm.devices[address] = device
device.states[0x01].register_updates(callbacks.callbackmethod1)
msg = StandardReceive(address,
target,
COMMAND_LIGHT_ON_0X11_NONE,
cmd2=cmd2,
flags=MessageFlags.create(
MESSAGE_FLAG_BROADCAST_0X80, 0, 0, 0))
plm.message_received(msg)
yield from asyncio.sleep(.1, loop=loop)
assert callbacks.callbackvalue1 == 0x6f
async def run_test(loop):
"""Asyncio test method."""
class lightStatus():
"""Callback class to capture state changes."""
lightOnLevel1 = None
lightOnLevel2 = None
# pylint: disable=unused-argument
def device_status_callback1(self, device_id, state, value):
"""Callback method to capture upper outlet changes."""
self.lightOnLevel1 = value
# pylint: disable=unused-argument
def device_status_callback2(self, device_id, state, value):
"""Callback method to capture lower outlet changes."""
self.lightOnLevel2 = value
mockPLM = MockPLM(loop)
address = '1a2b3c'
target = '4d5e6f'
cat = 0x02
subcat = 0x0d
product_key = None
description = 'ToggleLinc Relay'
model = '2466S'
callbacks = lightStatus()
device = SwitchedLightingControl_2663_222(mockPLM, address, cat,
subcat, product_key,
description, model)
mockPLM.devices[address] = device
assert device.states[0x01].name == 'outletTopOnOff'
assert device.states[0x02].name == 'outletBottomOnOff'
device.states[0x01].register_updates(callbacks.device_status_callback1)
device.states[0x02].register_updates(callbacks.device_status_callback2)
device.states[0x02].async_refresh_state()
await asyncio.sleep(.1, loop)
ackmsg = StandardSend(address,
COMMAND_LIGHT_STATUS_REQUEST_0X19_0X01,
acknak=MESSAGE_ACK)
statusmsg = StandardReceive(address,
target, {
'cmd1': 0x03,
'cmd2': 0x01
},
flags=MessageFlags.create(
MESSAGE_TYPE_DIRECT_MESSAGE_ACK, 0, 2,
3))
mockPLM.message_received(ackmsg)
await asyncio.sleep(.1, loop)
mockPLM.message_received(statusmsg)
await asyncio.sleep(.1, loop)
assert callbacks.lightOnLevel2 == 0x00
def run_test(loop):
"""Asyncio test method."""
plm = MockPLM(loop)
address = '1a2b3c'
cat = 0x01
subcat = 0x04
product_key = None
description = 'SwitchLinc Dimmer (1000W)'
model = '2476DH'
device = DimmableLightingControl(plm, address, cat, subcat,
product_key, description, model)
assert device.address.hex == address
assert device.cat == cat
assert device.subcat == subcat
assert device.product_key == 0x00 # Product key should not be None
assert device.description == description
assert device.model == model
assert device.id == address
plm.devices[device.address.hex] = device
callbacks = MockCallbacks()
device.states[0x01].register_updates(callbacks.callbackmethod1)
receivedmsg = StandardReceive(address,
'000001',
COMMAND_LIGHT_ON_0X11_NONE,
cmd2=0x66,
flags=MessageFlags.create(
MESSAGE_TYPE_ALL_LINK_BROADCAST, 0,
2, 3))
plm.message_received(receivedmsg)
yield from asyncio.sleep(.1, loop=loop)
assert callbacks.callbackvalue1 == 0x66
receivedmsg = StandardReceive(address,
'000001',
COMMAND_LIGHT_OFF_0X13_0X00,
flags=MessageFlags.create(
MESSAGE_TYPE_ALL_LINK_BROADCAST, 0,
2, 3))
plm.message_received(receivedmsg)
yield from asyncio.sleep(.1, loop=loop)
assert callbacks.callbackvalue1 == 0x00
def run_test(loop):
"""Asyncio test to run."""
plm = MockPLM(loop)
address = '1a2b3c'
target = '4d5e6f'
cat = 0x01
subcat = 0x04
product_key = None
description = 'SwitchLinc Dimmer (1000W)'
model = '2476DH'
device = DimmableLightingControl(plm, address, cat, subcat,
product_key, description, model)
assert device.address.hex == address
assert device.cat == cat
assert device.subcat == subcat
assert device.product_key == 0x00 # Product key should not be None
assert device.description == description
assert device.model == model
assert device.id == address
plm.devices[device.address.hex] = device
callbacks = MockCallbacks()
device.states[0x01].register_updates(callbacks.callbackmethod1)
device.async_refresh_state()
yield from asyncio.sleep(.1, loop=loop)
receivedmsg = StandardSend(address,
COMMAND_LIGHT_STATUS_REQUEST_0X19_0X00,
acknak=MESSAGE_ACK)
plm.message_received(receivedmsg)
yield from asyncio.sleep(.1, loop=loop)
receivedmsg = StandardReceive(address,
target, {
'cmd1': 0x08,
'cmd2': 0x27
},
flags=MessageFlags.create(
MESSAGE_TYPE_DIRECT_MESSAGE_ACK, 0,
2, 3))
plm.message_received(receivedmsg)
yield from asyncio.sleep(.1, loop=loop)
sentmsg = StandardSend(address, COMMAND_LIGHT_STATUS_REQUEST_0X19_0X00)
assert plm.sentmessage == sentmsg.hex
assert callbacks.callbackvalue1 == 0x27
def run_test(loop):
"""Asyncio test."""
plm = MockPLM(loop)
address = '1a2b3c'
target = '4d5e6f'
cat = 0x01
subcat = 0x2e
product_key = 0x00
description = 'FanLinc Dual Band'
model = '2475F'
device = DimmableLightingControl_2475F(plm, address, cat, subcat,
product_key, description, model)
plm.devices[device.address.hex] = device
callbacks = MockCallbacks()
device.states[0x02].register_updates(callbacks.callbackmethod1)
device.states[0x02].async_refresh_state()
yield from asyncio.sleep(.1, loop=loop)
receivedmsg = StandardSend(address,
COMMAND_LIGHT_STATUS_REQUEST_0X19_NONE,
cmd2=0x03,
acknak=MESSAGE_ACK)
plm.message_received(receivedmsg)
yield from asyncio.sleep(.1, loop=loop)
receivedmsg = StandardReceive(address,
target, {
'cmd1': 0x08,
'cmd2': 0x27
},
flags=MessageFlags.create(
MESSAGE_TYPE_DIRECT_MESSAGE_ACK, 0,
2, 3))
plm.message_received(receivedmsg)
yield from asyncio.sleep(.1, loop=loop)
sentmsg = StandardSend(address,
COMMAND_LIGHT_STATUS_REQUEST_0X19_NONE,
cmd2=0x03)
assert plm.sentmessage == sentmsg.hex
assert callbacks.callbackvalue1 == 0x27
async def run_test(loop):
"""Asyncio test to run."""
plm = MockPLM(loop)
address = '1a2b3c'
target = '4d5e6f'
cat = 0x01
subcat = 0x04
product_key = None
description = 'SwitchLinc Dimmer (1000W)'
model = '2476DH'
device = DimmableLightingControl(plm, address, cat, subcat,
product_key, description, model)
assert device.address.hex == address
assert device.cat == cat
assert device.subcat == subcat
assert device.product_key == 0x00 # Product key should not be None
assert device.description == description
assert device.model == model
assert device.id == address
plm.devices[device.address.hex] = device
callbacks = MockCallbacks()
device.states[0x01].register_updates(callbacks.callbackmethod1)
device.states[0x01].on()
await asyncio.sleep(.1, loop=loop)
plm.message_received(StandardSend(
address, COMMAND_LIGHT_ON_0X11_NONE, cmd2=0xff,
acknak=MESSAGE_ACK))
await asyncio.sleep(.1, loop=loop)
plm.message_received(StandardReceive(
address, target, COMMAND_LIGHT_ON_0X11_NONE, cmd2=0xff,
flags=MessageFlags.create(
MESSAGE_TYPE_DIRECT_MESSAGE_ACK, 0, 2, 3)))
await asyncio.sleep(.1, loop=loop)
sentmsg = StandardSend(address, COMMAND_LIGHT_ON_0X11_NONE, cmd2=0xff)
assert plm.sentmessage == sentmsg.hex
assert callbacks.callbackvalue1 == 0xff
device.states[0x01].off()
await asyncio.sleep(.1, loop=loop)
recievedmsg = StandardSend(address, COMMAND_LIGHT_OFF_0X13_0X00,
acknak=MESSAGE_ACK)
plm.message_received(recievedmsg)
await asyncio.sleep(.1, loop=loop)
recievedmsg = StandardReceive(
address, target, COMMAND_LIGHT_OFF_0X13_0X00,
flags=MessageFlags.create(MESSAGE_TYPE_DIRECT_MESSAGE_ACK,
0, 2, 3))
plm.message_received(recievedmsg)
await asyncio.sleep(.1, loop=loop)
sentmsg = StandardSend(address, COMMAND_LIGHT_OFF_0X13_0X00)
assert plm.sentmessage == sentmsg.hex
assert callbacks.callbackvalue1 == 0x00
device.states[0x01].set_level(0x55)
await asyncio.sleep(.1, loop=loop)
recievedmsg = StandardSend(address, COMMAND_LIGHT_ON_0X11_NONE,
cmd2=0x55, acknak=MESSAGE_ACK)
plm.message_received(recievedmsg)
await asyncio.sleep(.1, loop=loop)
recievedmsg = StandardReceive(
address, target, COMMAND_LIGHT_ON_0X11_NONE, cmd2=0x55,
flags=MessageFlags.create(MESSAGE_TYPE_DIRECT_MESSAGE_ACK,
0, 2, 3))
plm.message_received(recievedmsg)
await asyncio.sleep(.1, loop=loop)
sentmsg = StandardSend(address, COMMAND_LIGHT_ON_0X11_NONE,
cmd2=0x55)
assert plm.sentmessage == sentmsg.hex
assert callbacks.callbackvalue1 == 0x55
async def run_test(loop):
"""Asyncio test."""
class fanLincStatus():
"""Callback class to capture sensor changes."""
lightOnLevel = None
fanOnLevel = None
# pylint: disable=unused-argument
def device_status_callback1(self, device_id, state, value):
"""Callback method to capture light changes."""
self.lightOnLevel = value
# pylint: disable=unused-argument
def device_status_callback2(self, device_id, state, value):
"""Callback method to capture fan changes."""
self.fanOnLevel = value
mockPLM = MockPLM(loop)
address = '1a2b3c'
target = '4d5e6f'
cat = 0x01
subcat = 0x2e
product_key = 0x00
description = 'FanLinc Dual Band'
model = '2475F'
callbacks = fanLincStatus()
device = DimmableLightingControl_2475F(mockPLM, address, cat, subcat,
product_key, description, model)
mockPLM.devices[device.address.hex] = device
assert device.states[0x01].name == 'lightOnLevel'
assert device.states[0x02].name == 'fanOnLevel'
device.states[0x01].register_updates(callbacks.device_status_callback1)
device.states[0x02].register_updates(callbacks.device_status_callback2)
device.states[0x01].async_refresh_state()
await asyncio.sleep(.1, loop=loop)
ackmsg = StandardSend(address, COMMAND_LIGHT_STATUS_REQUEST_0X19_0X00,
acknak=MESSAGE_ACK)
statusmsg = StandardReceive(
address, target, {'cmd1': 0xdf, 'cmd2': 0x55},
flags=MessageFlags.create(MESSAGE_TYPE_DIRECT_MESSAGE_ACK,
0, 2, 3))
mockPLM.message_received(ackmsg)
await asyncio.sleep(.1, loop=loop)
mockPLM.message_received(statusmsg)
await asyncio.sleep(.1, loop=loop)
assert callbacks.lightOnLevel == 0x55
device.states[0x02].async_refresh_state()
await asyncio.sleep(.1, loop=loop)
ackmsg = StandardSend(address, {'cmd1': 0x19, 'cmd2': 0x03},
flags=0x00, acknak=MESSAGE_ACK)
statusmsg = StandardReceive(
address, target, {'cmd1': 0xab, 'cmd2': 0x77},
flags=MessageFlags.create(MESSAGE_TYPE_DIRECT_MESSAGE_ACK,
0, 2, 3))
mockPLM.message_received(ackmsg)
await asyncio.sleep(.1, loop=loop)
mockPLM.message_received(statusmsg)
await asyncio.sleep(.1, loop=loop)
assert callbacks.lightOnLevel == 0x55
assert callbacks.fanOnLevel == 0x77
def _run_test(loop):
"""Test on/off sensor."""
plm = MockPLM(loop)
address = '1a2b3c'
cat = 0x10
subcat = 0x00
product_key = 0x00
description = 'Generic Security, Heath and Safety Device'
model = ''
callbacks = MockCallbacks()
device = SecurityHealthSafety_2852_222(plm, address, cat, subcat,
product_key, description, model)
plm.devices[address] = device
device.states[0x01].register_updates(callbacks.callbackmethod1)
device.states[0x02].register_updates(callbacks.callbackmethod2)
device.states[0x04].register_updates(callbacks.callbackmethod4)
# Test Dry message received
msg = StandardReceive(
address=address,
target=bytearray([0x00, 0x00, 0x01]),
commandtuple=COMMAND_LIGHT_ON_0X11_NONE, cmd2=0x01,
flags=MessageFlags.create(MESSAGE_TYPE_ALL_LINK_BROADCAST,
0, 3, 3))
plm.message_received(msg)
yield from asyncio.sleep(.1, loop=loop)
assert callbacks.callbackvalue1 == 1
assert callbacks.callbackvalue2 == 0
assert callbacks.callbackvalue4 == 0x11
# Test wet message received
msg = StandardReceive(
address=address,
target=bytearray([0x00, 0x00, 0x02]),
commandtuple=COMMAND_LIGHT_ON_0X11_NONE, cmd2=0x02,
flags=MessageFlags.create(MESSAGE_TYPE_ALL_LINK_BROADCAST,
0, 3, 3))
plm.message_received(msg)
yield from asyncio.sleep(.1, loop=loop)
assert callbacks.callbackvalue1 == 0
assert callbacks.callbackvalue2 == 1
assert callbacks.callbackvalue4 == 0x13
# Test dry heartbeat received
msg = StandardReceive(
address=address,
target=bytearray([0x00, 0x00, 0x04]),
commandtuple=COMMAND_LIGHT_ON_0X11_NONE, cmd2=0x04,
flags=MessageFlags.create(MESSAGE_TYPE_ALL_LINK_BROADCAST,
0, 3, 3))
plm.message_received(msg)
yield from asyncio.sleep(.1, loop=loop)
assert callbacks.callbackvalue1 == 1
assert callbacks.callbackvalue2 == 0
# Test wet heartbeat received
msg = StandardReceive(
address=address,
target=bytearray([0x00, 0x00, 0x04]),
commandtuple={'cmd1': 0x13, 'cmd2': 0x04},
flags=MessageFlags.create(MESSAGE_TYPE_ALL_LINK_BROADCAST,
0, 3, 3))
plm.message_received(msg)
yield from asyncio.sleep(.1, loop=loop)
assert callbacks.callbackvalue1 == 0
assert callbacks.callbackvalue2 == 1
assert callbacks.callbackvalue4 == 0x13
