def run_internal(self):
""" Run CM_03 test. """
# Precondition
_, _ = mbim_open_generic_sequence.MBIMOpenGenericSequence(
self.test_context).run()
# Step 1
open_message, response_message = (
mbim_open_generic_sequence.MBIMOpenGenericSequence(
self.test_context).run())
# Validate function's behaviour for an unsynchronized MBIM_OPEN_MSG.
if response_message.message_type == mbim_constants.MBIM_CLOSE_DONE:
mbim_errors.log_and_raise(mbim_errors.MBIMComplianceAssertionError,
'mbim1.0:9.3.1#1')
def run_precondition(self, ntb_format):
"""
Runs all the precondition sequences for data transfer tests.
@param ntb_format: Whether to send/receive an NTB16 or NTB32 frame.
Possible values: NTB_FORMAT_16, NTB_FORMAT_32 (mbim_constants)
@returns tuple of (desc_sequence, open_sequence, connect_sequence) where,
desc_sequence - Handle to run the get descriptor sequence.
open_sequence - Handle to run the open sequence.
connect_sequence - Handle to run the connect sequence.
"""
desc_sequence = get_descriptors_sequence.GetDescriptorsSequence(
self.device_context)
descriptors = desc_sequence.run()
self.device_context.update_descriptor_cache(descriptors)
open_sequence = mbim_open_generic_sequence.MBIMOpenGenericSequence(
self.device_context)
open_sequence.run(ntb_format=ntb_format)
connect_seq = connect_sequence.ConnectSequence(self.device_context)
connect_seq.run()
# Devices may not support SetNtbFormat(), so fail the NTB32 tests on
# such devices.
if ((ntb_format == mbim_constants.NTB_FORMAT_32)
and (self.device_context.current_ntb_format != ntb_format)):
mbim_errors.log_and_raise(
mbim_errors.MBIMComplianceFrameworkError,
'Device does not support NTB 32 format.')
return (desc_sequence, open_sequence, connect_seq)
def run_internal(self):
""" Run CM_05 test. """
# Precondition
mbim_open_generic_sequence.MBIMOpenGenericSequence(
self.test_context).run()
caps_command_message = mbim_control.MBIMCommandMessage(
device_service_id=mbim_constants.UUID_BASIC_CONNECT.bytes,
cid=mbim_constants.MBIM_CID_DEVICE_CAPS,
command_type=mbim_constants.COMMAND_TYPE_QUERY,
information_buffer_length=0)
caps_packets = caps_command_message.generate_packets()
services_command_message = mbim_control.MBIMCommandMessage(
device_service_id=mbim_constants.UUID_BASIC_CONNECT.bytes,
cid=mbim_constants.MBIM_CID_DEVICE_SERVICES,
command_type=mbim_constants.COMMAND_TYPE_QUERY,
information_buffer_length=0)
services_packets = services_command_message.generate_packets()
self.caps_transaction_id = caps_command_message.transaction_id
self.services_transaction_id = services_command_message.transaction_id
self.channel = mbim_channel.MBIMChannel(
{
'idVendor': self.test_context.id_vendor,
'idProduct': self.test_context.id_product
}, self.test_context.mbim_communication_interface.bInterfaceNumber,
self.test_context.interrupt_endpoint.bEndpointAddress,
self.test_context.mbim_functional.wMaxControlMessage)
# Step 1
self.channel.unidirectional_transaction(*caps_packets)
# Step 2
self.channel.unidirectional_transaction(*services_packets)
utils.poll_for_condition(
self._get_response_packets,
timeout=5,
exception=mbim_errors.MBIMComplianceChannelError(
'Failed to retrieve the response packets to specific '
'control messages.'))
self.channel.close()
caps_response_message = mbim_control.parse_response_packets(
self.caps_response_packet)
services_response_message = mbim_control.parse_response_packets(
self.services_response_packet)
# Step 3
if not ((caps_response_message.transaction_id
== caps_command_message.transaction_id) and
(caps_response_message.device_service_id
== caps_command_message.device_service_id)
and caps_response_message.cid == caps_command_message.cid and
(services_command_message.transaction_id
== services_response_message.transaction_id) and
(services_command_message.device_service_id
== services_response_message.device_service_id) and
services_command_message.cid == services_response_message.cid):
mbim_errors.log_and_raise(mbim_errors.MBIMComplianceAssertionError,
'mbim1.0:8.1.2#2')
def run_internal(self):
""" Run CM_13 test. """
# Precondition
mbim_open_generic_sequence.MBIMOpenGenericSequence(
self.test_context).run()
connect_sequence.ConnectSequence(self.test_context).run()
mbim_close_sequence.MBIMCloseSequence(self.test_context).run()
mbim_open_generic_sequence.MBIMOpenGenericSequence(
self.test_context).run()
# Step 1
connect_info_structure = mbim_data.MBIMConnectInfoStructure(
session_id=0,
activation_state=0,
voice_call_state=0,
ip_type=0,
context_type=mbim_constants.MBIM_CONTEXT_TYPE_NONE.bytes,
nw_error=0)
command_message = mbim_control.MBIMCommandMessage(
message_length=84,
total_fragments=1,
current_fragment=0,
device_service_id=mbim_constants.UUID_BASIC_CONNECT.bytes,
cid=mbim_constants.MBIM_CID_CONNECT,
command_type=mbim_constants.COMMAND_TYPE_QUERY,
information_buffer_length=36,
information_buffer=connect_info_structure.pack())
packets = command_message.generate_packets()
channel = mbim_channel.MBIMChannel(
{'idVendor': self.test_context.id_vendor,
'idProduct': self.test_context.id_product},
self.test_context.mbim_communication_interface.bInterfaceNumber,
self.test_context.interrupt_endpoint.bEndpointAddress,
self.test_context.mbim_functional.wMaxControlMessage)
response_packets = channel.bidirectional_transaction(*packets)
channel.close()
# Step 2
response_message = mbim_control.parse_response_packets(response_packets)
# Step 3
if (response_message.status_codes !=
mbim_constants.MBIM_STATUS_CONTEXT_NOT_ACTIVATED):
mbim_errors.log_and_raise(mbim_errors.MBIMComplianceAssertionError,
'mbim1.0:9.3.2#3')
def run_internal(self):
""" Run CM_03 test. """
# Precondition
descriptors = get_descriptors_sequence.GetDescriptorsSequence(
self.device_context).run()
self.device_context.update_descriptor_cache(descriptors)
mbim_open_generic_sequence.MBIMOpenGenericSequence(
self.device_context).run()
# Step 1
_, response_message = (
mbim_open_generic_sequence.MBIMOpenGenericSequence(
self.device_context).run())
# Validate function's behaviour for an unsynchronized MBIM_OPEN_MSG.
if response_message.message_type == mbim_constants.MBIM_CLOSE_DONE:
mbim_errors.log_and_raise(mbim_errors.MBIMComplianceAssertionError,
'mbim1.0:9.3.1#1')
def run_internal(self):
""" Run CM_10 test. """
# Precondition
mbim_open_generic_sequence.MBIMOpenGenericSequence(
self.test_context).run()
# Step 1
close_message, response_message = mbim_close_sequence.MBIMCloseSequence(
self.test_context).run()
def run_internal(self):
""" Run CM_02 test. """
# Step 1
open_message, response_message = (
mbim_open_generic_sequence.MBIMOpenGenericSequence(
self.test_context).run())
# Validate message length of response to MBIM_OPEN_MESSAGE.
if response_message.message_length < 0x0C:
mbim_errors.log_and_raise(mbim_errors.MBIMComplianceAssertionError,
'mbim1.0:9.1#2')
def run_internal(self):
""" Run the CM_01 test. """
# Precondition.
descriptors = get_descriptors_sequence.GetDescriptorsSequence(
self.device_context).run()
self.device_context.update_descriptor_cache(descriptors)
# Step 1
open_message, response_message = (
mbim_open_generic_sequence.MBIMOpenGenericSequence(
self.device_context).run())
def run_internal(self):
""" Run CM_10 test. """
# Precondition
descriptors = get_descriptors_sequence.GetDescriptorsSequence(
self.device_context).run()
self.device_context.update_descriptor_cache(descriptors)
mbim_open_generic_sequence.MBIMOpenGenericSequence(
self.device_context).run()
# Step 1
close_message, response_message = mbim_close_sequence.MBIMCloseSequence(
self.device_context).run()
def run_internal(self):
""" Run CM_06 test. """
# Precondition
mbim_open_generic_sequence.MBIMOpenGenericSequence(
self.test_context).run()
# Step 1
command_message, response_message = (
mbim_cid_device_caps_sequence.MBIMCIDDeviceCapsSequence(
self.test_context).run())
if response_message.status_codes != mbim_constants.MBIM_STATUS_SUCCESS:
mbim_errors.log_and_raise(mbim_errors.MBIMComplianceAssertionError,
'mbim1.0:9.4.5#1')
def run_internal(self):
""" Run CM_04 test. """
# Precondition
mbim_open_generic_sequence.MBIMOpenGenericSequence(
self.test_context).run()
# Step 1
command_message, response_message = (
mbim_cid_device_caps_sequence.MBIMCIDDeviceCapsSequence(
self.test_context).run())
# Validate |transaction_id| in the response to MBIM_COMMAND_MSG.
if response_message.transaction_id != command_message.transaction_id:
mbim_errors.log_and_raise(mbim_errors.MBIMComplianceAssertionError,
'mbim1.0:9.4.3')
def run_internal(self):
""" Run CM_09 test. """
# Precondition
mbim_open_generic_sequence.MBIMOpenGenericSequence(
self.test_context).run()
# Step 1
_, _, notifications = (connect_sequence.ConnectSequence(
self.test_context).run())
# Step 2
for notification in notifications:
if notification.transaction_id != 0:
mbim_errors.log_and_raise(
mbim_errors.MBIMComplianceAssertionError, 'mbim1.0:9.1#1')
def run_internal(self):
""" Run the CM_02 test. """
# Precondition.
descriptors = get_descriptors_sequence.GetDescriptorsSequence(
self.device_context).run()
self.device_context.update_descriptor_cache(descriptors)
# Step 1
_, response_message = (
mbim_open_generic_sequence.MBIMOpenGenericSequence(
self.device_context).run())
# Validate message length of response to MBIM_OPEN_MESSAGE.
if response_message.message_length < 0x0C:
mbim_errors.log_and_raise(mbim_errors.MBIMComplianceAssertionError,
'mbim1.0:9.1#2')
def run_internal(self):
""" Run CM_15 test. """
# Precondition
descriptors = get_descriptors_sequence.GetDescriptorsSequence(
self.device_context).run()
self.device_context.update_descriptor_cache(descriptors)
open_sequence = mbim_open_generic_sequence.MBIMOpenGenericSequence(
self.device_context)
open_sequence.run(max_control_transfer_size=64)
# Step 1
caps_sequence = mbim_cid_device_caps_sequence.MBIMCIDDeviceCapsSequence(
self.device_context)
_, response_message = caps_sequence.run()
if not isinstance(response_message,
mbim_command_message.MBIMDeviceCapsInfo):
mbim_errors.log_and_raise(mbim_errors.MBIMComplianceAssertionError,
'mbim1.0:9.2')
def run_internal(self):
""" Run CM_09 test. """
# Precondition
descriptors = get_descriptors_sequence.GetDescriptorsSequence(
self.device_context).run()
self.device_context.update_descriptor_cache(descriptors)
mbim_open_generic_sequence.MBIMOpenGenericSequence(
self.device_context).run()
# Step 1
_, _, notifications = (connect_sequence.ConnectSequence(
self.device_context).run())
# Step 2
for notification in notifications:
if notification.transaction_id != 0:
mbim_errors.log_and_raise(
mbim_errors.MBIMComplianceAssertionError, 'mbim1.0:9.1#1')
def run_internal(self):
""" Run CM_14 test. """
# Precondition
descriptors = get_descriptors_sequence.GetDescriptorsSequence(
self.device_context).run()
self.device_context.update_descriptor_cache(descriptors)
mbim_open_generic_sequence.MBIMOpenGenericSequence(
self.device_context).run()
mbim_close_sequence.MBIMCloseSequence(self.device_context).run()
# Step 1
_, response_message, _ = (connect_sequence.ConnectSequence(
self.device_context).run(raise_exception_on_failure=False))
# Step 2
if ((response_message.message_type !=
mbim_constants.MBIM_FUNCTION_ERROR_MSG)
or (response_message.message_length != 16)):
mbim_errors.log_and_raise(mbim_errors.MBIMComplianceAssertionError,
'mbim1.0:9.3.4#2')
def run_internal(self):
""" Run CM_08 test. """
# Precondition
descriptors = get_descriptors_sequence.GetDescriptorsSequence(
self.device_context).run()
self.device_context.update_descriptor_cache(descriptors)
mbim_open_generic_sequence.MBIMOpenGenericSequence(
self.device_context).run()
# Step 1
device_context = self.device_context
descriptor_cache = device_context.descriptor_cache
command_message = mbim_message_request.MBIMCommand(
device_service_id=mbim_constants.UUID_BASIC_CONNECT.bytes,
cid=mbim_constants.MBIM_CID_RADIO_STATE,
command_type=mbim_constants.COMMAND_TYPE_SET,
information_buffer_length=4,
payload_buffer=array.array('B', struct.pack('I', 2)))
packets = mbim_message_request.generate_request_packets(
command_message, device_context.max_control_transfer_size)
channel = mbim_channel.MBIMChannel(
device_context._device,
descriptor_cache.mbim_communication_interface.bInterfaceNumber,
descriptor_cache.interrupt_endpoint.bEndpointAddress,
device_context.max_control_transfer_size)
response_packets = channel.bidirectional_transaction(*packets)
channel.close()
# Step 2
response_message = mbim_message_response.parse_response_packets(
response_packets)
# Step 3
if ((response_message.message_type != mbim_constants.MBIM_COMMAND_DONE)
or (response_message.status_codes
== mbim_constants.MBIM_STATUS_SUCCESS)
or response_message.information_buffer_length != 0):
mbim_errors.log_and_raise(mbim_errors.MBIMComplianceAssertionError,
'mbim1.0:9.4.5#3')
def run_internal(self):
""" Run ERR_04 test. """
# Precondition
descriptors = get_descriptors_sequence.GetDescriptorsSequence(
self.device_context).run()
self.device_context.update_descriptor_cache(descriptors)
open_sequence = mbim_open_generic_sequence.MBIMOpenGenericSequence(
self.device_context)
open_sequence.run(max_control_transfer_size=64)
# Step 1
request_message, response_message, _ = (
connect_sequence.ConnectSequence(self.device_context).run(
introduce_error_in_packets_order=[1, 0, 2],
raise_exception_on_failure=False))
# Step 2
if ((response_message.transaction_id != request_message.transaction_id)
or (response_message.message_type
== mbim_constants.MBIM_COMMAND_DONE)):
mbim_errors.log_and_raise(mbim_errors.MBIMComplianceAssertionError,
'mbim1.0:9.3.4.2#3')
def run_internal(self):
""" Run CM_07 test. """
# Precondition
descriptors = get_descriptors_sequence.GetDescriptorsSequence(
self.device_context).run()
self.device_context.update_descriptor_cache(descriptors)
mbim_open_generic_sequence.MBIMOpenGenericSequence(
self.device_context).run()
# Step 1
# 255 is an unsupported CID.
device_context = self.device_context
descriptor_cache = device_context.descriptor_cache
command_message = mbim_message_request.MBIMCommand(
device_service_id=mbim_constants.UUID_BASIC_CONNECT.bytes,
cid=255,
command_type=mbim_constants.COMMAND_TYPE_QUERY,
information_buffer_length=0)
packets = mbim_message_request.generate_request_packets(
command_message, device_context.max_control_transfer_size)
channel = mbim_channel.MBIMChannel(
device_context._device,
descriptor_cache.mbim_communication_interface.bInterfaceNumber,
descriptor_cache.interrupt_endpoint.bEndpointAddress,
device_context.max_control_transfer_size)
response_packets = channel.bidirectional_transaction(*packets)
channel.close()
# Step 2
response_message = mbim_message_response.parse_response_packets(
response_packets)
# Step 3
if (response_message.message_type != mbim_constants.MBIM_COMMAND_DONE
or (response_message.status_codes !=
mbim_constants.MBIM_STATUS_NO_DEVICE_SUPPORT)):
mbim_errors.log_and_raise(mbim_errors.MBIMComplianceAssertionError,
'mbim1.0:9.4.5#2')
def run_internal(self):
""" Run CM_08 test. """
# Precondition
mbim_open_generic_sequence.MBIMOpenGenericSequence(
self.test_context).run()
# Step 1
command_message = mbim_control.MBIMCommandMessage(
message_length=52,
total_fragments=1,
current_fragment=0,
device_service_id=mbim_constants.UUID_BASIC_CONNECT.bytes,
cid=mbim_constants.MBIM_CID_RADIO_STATE,
command_type=mbim_constants.COMMAND_TYPE_SET,
information_buffer_length=4,
information_buffer=array.array('B', struct.pack('I', 2)))
packets = command_message.generate_packets()
channel = mbim_channel.MBIMChannel(
{
'idVendor': self.test_context.id_vendor,
'idProduct': self.test_context.id_product
}, self.test_context.mbim_communication_interface.bInterfaceNumber,
self.test_context.interrupt_endpoint.bEndpointAddress,
self.test_context.mbim_functional.wMaxControlMessage)
response_packets = channel.bidirectional_transaction(*packets)
channel.close()
# Step 2
response_message = mbim_control.parse_response_packets(
response_packets)
# Step 3
if ((response_message.message_type != mbim_constants.MBIM_COMMAND_DONE)
or (response_message.status_codes
== mbim_constants.MBIM_STATUS_SUCCESS)
or response_message.information_buffer_length != 0):
mbim_errors.log_and_raise(mbim_errors.MBIMComplianceAssertionError,
'mbim1.0:9.4.5#3')
def run_internal(self):
""" Run ERR_02 test. """
# Precondition
descriptors = get_descriptors_sequence.GetDescriptorsSequence(
self.device_context).run()
self.device_context.update_descriptor_cache(descriptors)
open_sequence = mbim_open_generic_sequence.MBIMOpenGenericSequence(
self.device_context)
open_sequence.run(max_control_transfer_size=64)
# Step 1
request_message, response_message, _ = (
connect_sequence.ConnectSequence(self.device_context).run(
introduce_error_in_packets_order=[1, 0, 2],
raise_exception_on_failure=False))
# Step 2
if ((response_message.message_type !=
mbim_constants.MBIM_FUNCTION_ERROR_MSG)
or (response_message.error_status_code !=
mbim_constants.MBIM_ERROR_FRAGMENT_OUT_OF_SEQUENCE)):
mbim_errors.log_and_raise(mbim_errors.MBIMComplianceAssertionError,
'mbim1.0:9.3.4#3')
def run_internal(self):
""" Run ERR_05 test. """
# Precondition
descriptors = get_descriptors_sequence.GetDescriptorsSequence(
self.device_context).run()
self.device_context.update_descriptor_cache(descriptors)
open_sequence = mbim_open_generic_sequence.MBIMOpenGenericSequence(
self.device_context)
open_sequence.run(max_control_transfer_size=64)
# Step 1
request_message, first_response_message, notifications = (
connect_sequence.ConnectSequence(self.device_context).run(
introduce_error_in_packets_order=[1, 1],
raise_exception_on_failure=False))
if len(notifications) > 1:
mbim_errors.log_and_raise(
mbim_errors.MBIMComplianceTestError,
'Not expecting more than 1 pending response.')
second_response_message = notifications[0]
# Step 2
if (((first_response_message.transaction_id !=
request_message.transaction_id) or
(first_response_message.message_type !=
mbim_constants.MBIM_FUNCTION_ERROR_MSG) or
(first_response_message.error_status_code !=
mbim_constants.MBIM_ERROR_FRAGMENT_OUT_OF_SEQUENCE)) or
((second_response_message.transaction_id !=
request_message.transaction_id) or
(second_response_message.message_type !=
mbim_constants.MBIM_FUNCTION_ERROR_MSG) or
(second_response_message.error_status_code !=
mbim_constants.MBIM_ERROR_FRAGMENT_OUT_OF_SEQUENCE))):
mbim_errors.log_and_raise(mbim_errors.MBIMComplianceAssertionError,
'mbim1.0:9.3.4.2#4')
def run_internal(self):
""" Run CM_07 test. """
# Precondition
mbim_open_generic_sequence.MBIMOpenGenericSequence(
self.test_context).run()
# Step 1
# 255 is an unsupported CID.
command_message = mbim_control.MBIMCommandMessage(
message_length=48,
total_fragments=1,
current_fragment=0,
device_service_id=mbim_constants.UUID_BASIC_CONNECT.bytes,
cid=255,
command_type=mbim_constants.COMMAND_TYPE_QUERY,
information_buffer_length=0)
packets = command_message.generate_packets()
channel = mbim_channel.MBIMChannel(
{
'idVendor': self.test_context.id_vendor,
'idProduct': self.test_context.id_product
}, self.test_context.mbim_communication_interface.bInterfaceNumber,
self.test_context.interrupt_endpoint.bEndpointAddress,
self.test_context.mbim_functional.wMaxControlMessage)
response_packets = channel.bidirectional_transaction(*packets)
channel.close()
# Step 2
response_message = mbim_control.parse_response_packets(
response_packets)
# Step 3
if (response_message.message_type != mbim_constants.MBIM_COMMAND_DONE
or (response_message.status_codes !=
mbim_constants.MBIM_STATUS_NO_DEVICE_SUPPORT)):
mbim_errors.log_and_raise(mbim_errors.MBIMComplianceAssertionError,
'mbim1.0:9.4.5#2')
def run_internal(self):
""" Run the CM_01 test. """
# Precondition.
desc_sequence = get_descriptors_sequence.GetDescriptorsSequence(
self.device_context)
descriptors = desc_sequence.run()
self.device_context.update_descriptor_cache(descriptors)
open_sequence = mbim_open_generic_sequence.MBIMOpenGenericSequence(
self.device_context)
open_sequence.run()
caps_sequence = mbim_cid_device_caps_sequence.MBIMCIDDeviceCapsSequence(
self.device_context)
_, caps_response = caps_sequence.run()
# Step1
if (caps_response.cellular_class
& mbim_constants.CELLULAR_CLASS_MASK_CDMA):
if not ((caps_response.control_caps
& mbim_constants.CTRL_CAPS_MASK_CDMA_MOBILE_IP) or
(caps_response.control_caps
& mbim_constants.CTRL_CAPS_MASK_CDMA_SIMPLE_IP)):
mbim_errors.log_and_raise(
mbim_errors.MBIMComplianceAssertionError,
'mbim1.0:10.5.1.3#1')
def run_internal(self):
""" Run CM_01 test. """
# Step 1
open_message, response_message = (
mbim_open_generic_sequence.MBIMOpenGenericSequence(
self.test_context).run())
def run_internal(self):
""" Run CM_05 test. """
# Precondition
descriptors = get_descriptors_sequence.GetDescriptorsSequence(
self.device_context).run()
self.device_context.update_descriptor_cache(descriptors)
mbim_open_generic_sequence.MBIMOpenGenericSequence(
self.device_context).run()
device_context = self.device_context
descriptor_cache = device_context.descriptor_cache
self.channel = mbim_channel.MBIMChannel(
device_context._device,
descriptor_cache.mbim_communication_interface.bInterfaceNumber,
descriptor_cache.interrupt_endpoint.bEndpointAddress,
device_context.max_control_transfer_size)
# Step 1
caps_command_message = mbim_command_message.MBIMDeviceCapsQuery()
caps_packets = mbim_message_request.generate_request_packets(
caps_command_message, device_context.max_control_transfer_size)
self.caps_transaction_id = caps_command_message.transaction_id
self.channel.unidirectional_transaction(*caps_packets)
# Step 2
services_command_message = (
mbim_command_message.MBIMDeviceServicesQuery())
services_packets = mbim_message_request.generate_request_packets(
services_command_message, device_context.max_control_transfer_size)
self.services_transaction_id = services_command_message.transaction_id
self.channel.unidirectional_transaction(*services_packets)
# Step 3
utils.poll_for_condition(
self._get_response_packets,
timeout=5,
exception=mbim_errors.MBIMComplianceChannelError(
'Failed to retrieve the response packets to specific '
'control messages.'))
self.channel.close()
caps_response_message = self.caps_response
services_response_message = self.services_response
is_caps_message_valid = isinstance(
caps_response_message, mbim_command_message.MBIMDeviceCapsInfo)
is_services_message_valid = isinstance(
services_response_message,
mbim_command_message.MBIMDeviceServicesInfo)
if not ((is_caps_message_valid and is_services_message_valid) and
(caps_response_message.transaction_id
== caps_command_message.transaction_id) and
(caps_response_message.device_service_id
== caps_command_message.device_service_id)
and caps_response_message.cid == caps_command_message.cid and
(services_command_message.transaction_id
== services_response_message.transaction_id) and
(services_command_message.device_service_id
== services_response_message.device_service_id) and
services_command_message.cid == services_response_message.cid):
mbim_errors.log_and_raise(mbim_errors.MBIMComplianceAssertionError,
'mbim1.0:8.1.2#2')
