#
#   Copyright 2019 - The Android Open Source Project
#
#   Licensed under the Apache License, Version 2.0 (the "License");
#   you may not use this file except in compliance with the License.
#   You may obtain a copy of the License at
#
#       http://www.apache.org/licenses/LICENSE-2.0
#
#   Unless required by applicable law or agreed to in writing, software
#   distributed under the License is distributed on an "AS IS" BASIS,
#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#   See the License for the specific language governing permissions and
#   limitations under the License.

from datetime import timedelta

from mobly import asserts

from bluetooth_packets_python3 import l2cap_packets
from bluetooth_packets_python3 import RawBuilder
from bluetooth_packets_python3.l2cap_packets import FcsType
from bluetooth_packets_python3.l2cap_packets import Final
from bluetooth_packets_python3.l2cap_packets import Poll
from bluetooth_packets_python3.l2cap_packets import SegmentationAndReassembly
from bluetooth_packets_python3.l2cap_packets import SupervisoryFunction
from cert.behavior import when, anything, wait_until
from cert.event_stream import EventStream
from cert.gd_base_test import GdBaseTestClass
from cert.matchers import L2capMatchers
from cert.metadata import metadata
from cert.py_l2cap import PyL2cap
from cert.truth import assertThat
from facade import common_pb2
from google.protobuf import empty_pb2 as empty_proto
from l2cap.classic.cert.cert_l2cap import CertL2cap
from l2cap.classic.facade_pb2 import RetransmissionFlowControlMode
from neighbor.facade import facade_pb2 as neighbor_facade

# Assemble a sample packet.
SAMPLE_PACKET_DATA = b"\x19\x26\x08\x17"
SAMPLE_PACKET = RawBuilder([x for x in SAMPLE_PACKET_DATA])


class L2capTestBase(GdBaseTestClass):

    def setup_class(self):
        super().setup_class(dut_module='L2CAP', cert_module='HCI_INTERFACES')

    def setup_test(self):
        super().setup_test()

        self.dut_address = self.dut.hci_controller.GetMacAddressSimple()
        cert_address = common_pb2.BluetoothAddress(
            address=self.cert.controller_read_only_property.ReadLocalAddress(empty_proto.Empty()).address)

        self.dut_l2cap = PyL2cap(self.dut, cert_address)
        self.cert_l2cap = CertL2cap(self.cert)

    def teardown_test(self):
        self.cert_l2cap.close()
        self.dut_l2cap.close()
        super().teardown_test()

    def _setup_link_from_cert(self):
        self.dut.neighbor.EnablePageScan(neighbor_facade.EnableMsg(enabled=True))
        self.cert_l2cap.connect_acl(self.dut_address)

    def _open_unconfigured_channel_from_cert(self,
                                             signal_id=1,
                                             scid=0x0101,
                                             psm=0x33,
                                             mode=RetransmissionFlowControlMode.BASIC,
                                             fcs=None):

        dut_channel = self.dut_l2cap.register_dynamic_channel(psm, mode)
        cert_channel = self.cert_l2cap.open_channel(signal_id, psm, scid, fcs=fcs)

        return (dut_channel, cert_channel)

    def _open_channel_from_cert(self,
                                signal_id=1,
                                scid=0x0101,
                                psm=0x33,
                                mode=RetransmissionFlowControlMode.BASIC,
                                fcs=None,
                                req_config_options=None,
                                rsp_config_options=None):
        request_matcher = L2capMatchers.ConfigurationRequestView(scid)
        if rsp_config_options is not None:
            when(self.cert_l2cap).on_config_req(request_matcher).then().send_configuration_response(
                options=rsp_config_options)
        if rsp_config_options is None and fcs is not None:
            when(self.cert_l2cap).on_config_req(request_matcher).then().send_configuration_response(
                options=CertL2cap.config_option_ertm(fcs=fcs))

        (dut_channel, cert_channel) = self._open_unconfigured_channel_from_cert(signal_id, scid, psm, mode, fcs)
        if req_config_options is None:
            req_config_options = CertL2cap.config_option_ertm(
                fcs=fcs) if mode == RetransmissionFlowControlMode.ERTM else []

        cert_channel.send_configure_request(req_config_options)

        cert_channel.verify_configuration_response()

        wait_until(self.cert_l2cap).on_config_req(request_matcher).times(1)

        assertThat(cert_channel.is_configured()).isTrue()

        return (dut_channel, cert_channel)

    def _open_channel_from_dut(self, psm=0x33, mode=RetransmissionFlowControlMode.BASIC):
        dut_channel_future = self.dut_l2cap.connect_dynamic_channel_to_cert(psm, mode)
        cert_channel = self.cert_l2cap.verify_and_respond_open_channel_from_remote(psm)
        dut_channel = dut_channel_future.get_channel()

        cert_channel.verify_configuration_request_and_respond()
        outgoing_config = []
        if mode == RetransmissionFlowControlMode.ERTM:
            outgoing_config = CertL2cap.config_option_ertm()
        cert_channel.send_configure_request(outgoing_config)
        cert_channel.verify_configuration_response()

        return (dut_channel, cert_channel)


class L2capTest(L2capTestBase):

    def test_connect_dynamic_channel_and_send_data(self):
        self._setup_link_from_cert()

        (dut_channel, cert_channel) = self._open_channel_from_cert()

        dut_channel.send(b'abc')
        assertThat(cert_channel).emits(L2capMatchers.Data(b'abc'))

    def test_receive_packet_from_unknown_channel(self):
        self._setup_link_from_cert()

        (dut_channel, cert_channel) = self._open_channel_from_cert(scid=0x41, psm=0x33)

        i_frame = l2cap_packets.EnhancedInformationFrameBuilder(
            0x99, 0, Final.NOT_SET, 1, l2cap_packets.SegmentationAndReassembly.UNSEGMENTED, SAMPLE_PACKET)
        self.cert_l2cap.send_acl(i_frame)
        assertThat(cert_channel).emitsNone(L2capMatchers.SFrame(req_seq=4), timeout=timedelta(seconds=1))

    def test_open_two_channels(self):
        self._setup_link_from_cert()

        self._open_channel_from_cert(signal_id=1, scid=0x41, psm=0x41)
        self._open_channel_from_cert(signal_id=2, scid=0x43, psm=0x43)

    def test_connect_and_send_data_ertm_no_segmentation(self):
        self._setup_link_from_cert()

        (dut_channel, cert_channel) = self._open_channel_from_cert(
            mode=RetransmissionFlowControlMode.ERTM, fcs=FcsType.NO_FCS)

        dut_channel.send(b'abc' * 34)
        assertThat(cert_channel).emits(L2capMatchers.IFrame(tx_seq=0, payload=b'abc' * 34))

        cert_channel.send_i_frame(tx_seq=0, req_seq=1, payload=SAMPLE_PACKET)
        # todo verify received?

    @metadata(pts_test_id="L2CAP/COS/CED/BV-01-C", pts_test_name="Request Connection")
    def test_basic_operation_request_connection(self):
        """
        Verify that the IUT is able to request the connection establishment for
        an L2CAP data channel and initiate the configuration procedure.
        """
        self._setup_link_from_cert()
        (dut_channel, cert_channel) = self._open_channel_from_dut()

    @metadata(pts_test_id="L2CAP/COS/CED/BV-03-C", pts_test_name="Send data")
    def test_send_data(self):
        """
        Verify that the IUT is able to send DATA
        """
        self._setup_link_from_cert()

        (dut_channel, cert_channel) = self._open_channel_from_cert()
        dut_channel.send(b'hello')
        assertThat(cert_channel).emits(L2capMatchers.Data(b'hello'))

    @metadata(pts_test_id="L2CAP/COS/CED/BV-04-C", pts_test_name="Disconnect")
    def test_disconnect(self):
        """
        Verify that the IUT is able to disconnect the data channel
        """
        self._setup_link_from_cert()

        (dut_channel, cert_channel) = self._open_channel_from_cert()
        dut_channel.close_channel()
        cert_channel.verify_disconnect_request()

    @metadata(pts_test_id="L2CAP/COS/CED/BV-05-C", pts_test_name="Accept connection")
    def test_accept_connection(self):
        """
        Also verify that DUT can send 48 bytes PDU (minimal MTU)
        """
        self._setup_link_from_cert()

        (dut_channel, cert_channel) = self._open_channel_from_cert()
        dut_channel.send(b'a' * 48)
        assertThat(cert_channel).emits(L2capMatchers.Data(b'a' * 48))

    @metadata(pts_test_id="L2CAP/COS/CED/BV-07-C", pts_test_name="Accept Disconnect")
    def test_accept_disconnect(self):
        """
        Verify that the IUT is able to respond to the request to disconnect the
        data channel
        """
        self._setup_link_from_cert()

        (dut_channel, cert_channel) = self._open_channel_from_cert()
        cert_channel.disconnect_and_verify()

    @metadata(pts_test_id="L2CAP/COS/CED/BV-08-C", pts_test_name="Disconnect on Timeout")
    def test_disconnect_on_timeout(self):
        """
        Verify that the IUT disconnects the data channel and shuts down this
        channel if no response occurs
        """
        self._setup_link_from_cert()

        (dut_channel, cert_channel) = self._open_unconfigured_channel_from_cert()

        assertThat(self.cert_l2cap.get_control_channel()).emitsNone(L2capMatchers.ConfigurationResponse())
        # TODO: Verify that IUT sends disconnect request (not mandated)

    @metadata(pts_test_id="L2CAP/COS/CED/BV-09-C", pts_test_name="Receive Multi-Command Packet")
    def test_receive_multi_command_packet(self):
        """
        Verify that the IUT is able to receive more than one signaling command in one L2CAP
        packet.
        """
        self._setup_link_from_cert()

        psm = 0x33
        self.dut_l2cap.connect_dynamic_channel_to_cert(psm)
        self.cert_l2cap.verify_and_respond_open_channel_from_remote_and_send_config_req(psm)

        assertThat(self.cert_l2cap.get_control_channel()).emits(L2capMatchers.ConfigurationResponse())

    @metadata(pts_test_id="L2CAP/COS/CED/BV-11-C", pts_test_name="Configure MTU size")
    def test_configure_mtu_size(self):
        """
        Verify that the IUT is able to configure the supported MTU size
        """
        self._setup_link_from_cert()
        (dut_channel, cert_channel) = self._open_unconfigured_channel_from_cert()
        cert_channel.send_configure_request(CertL2cap.config_option_mtu_explicit(672))
        cert_channel.verify_configuration_request_and_respond()
        # TODO: Probably remove verify_configuration_request_and_respond

    @metadata(pts_test_id="L2CAP/COS/CFD/BV-01-C", pts_test_name="Continuation Flag")
    def test_continuation_flag(self):
        """
        Verify the IUT is able to receive configuration requests that have the
        continuation flag set
        """
        self._setup_link_from_cert()

        (dut_channel, cert_channel) = self._open_unconfigured_channel_from_cert()

        # Send configuration request with CONTINUE
        mtu_opt = l2cap_packets.MtuConfigurationOption()
        mtu_opt.mtu = 0x1234
        cert_channel.send_configure_request([mtu_opt], 2, l2cap_packets.Continuation.CONTINUE)

        flush_timeout_option = l2cap_packets.FlushTimeoutConfigurationOption()
        flush_timeout_option.flush_timeout = 65535
        cert_channel.send_configure_request([flush_timeout_option], 3, l2cap_packets.Continuation.END)

        assertThat(self.cert_l2cap.get_control_channel()).emits(L2capMatchers.ConfigurationResponse(), at_least_times=2)

    @metadata(pts_test_id="L2CAP/COS/CFD/BV-02-C", pts_test_name="Negotiation with Reject")
    def test_retry_config_after_rejection(self):
        """
        Verify that the IUT is able to perform negotiation while the Lower
        Tester rejects the proposed configuration parameter values
        """
        self._setup_link_from_cert()
        scid = 0x41
        when(self.cert_l2cap).on_config_req(
            L2capMatchers.ConfigurationRequestView(scid)).then().send_configuration_response(
                result=l2cap_packets.ConfigurationResponseResult.UNACCEPTABLE_PARAMETERS,
                options=CertL2cap.config_option_mtu_explicit(200)).send_configuration_response(options=[])
        (dut_channel, cert_channel) = self._open_unconfigured_channel_from_cert(scid=scid)

        assertThat(self.cert_l2cap.get_control_channel()).emits(L2capMatchers.ConfigurationRequest(), at_least_times=2)

    @metadata(pts_test_id="L2CAP/COS/CFD/BV-03-C", pts_test_name="Send Requested Options")
    def test_send_requested_options(self):
        """
        Verify that the IUT can receive a configuration request with no options
        and send the requested options to the Lower Tester
        """
        self._setup_link_from_cert()
        (dut_channel, cert_channel) = self._open_channel_from_cert(scid=0x41, psm=0x33)

        # TODO(hsz) implement me!

    @metadata(pts_test_id="L2CAP/COS/CFD/BV-08-C", pts_test_name="Non-blocking Config Response")
    def test_non_blocking_config_response(self):
        """
        Verify that the IUT does not block transmitting L2CAP_ConfigRsp while
        waiting for L2CAP_ConfigRsp from the Lower Tester
        """
        self._setup_link_from_cert()

        (dut_channel, cert_channel) = self._open_unconfigured_channel_from_cert()

        cert_channel.send_configure_request([])
        cert_channel.verify_configuration_response()
        cert_channel.verify_configuration_request_and_respond()

        # TODO(hsz) implement me!

    @metadata(pts_test_id="L2CAP/COS/CFD/BV-09-C", pts_test_name="Mandatory 48 Byte MTU")
    def test_mandatory_48_byte_mtu(self):
        """
        Verify that the IUT can support mandatory 48 byte MTU
        """
        self._setup_link_from_cert()
        (dut_channel,
         cert_channel) = self._open_channel_from_cert(req_config_options=CertL2cap.config_option_mtu_explicit(48))

        dut_channel.send(b"a" * 44)
        assertThat(cert_channel).emits(L2capMatchers.Data(b"a" * 44))

    @metadata(pts_test_id="L2CAP/COS/CFD/BV-11-C", pts_test_name="Negotiation of Unsupported Parameter")
    def test_negotiation_of_unsupported_parameter(self):
        """
        Verify that the IUT can negotiate when the Lower Tester proposes an unsupported configuration
        parameter value.
        """
        self._setup_link_from_cert()
        (dut_channel, cert_channel) = self._open_unconfigured_channel_from_cert()

        cert_channel.send_configure_request(CertL2cap.config_option_mtu_explicit(20))
        # Invalid because minimum is 48

        cert_channel.verify_configuration_response(l2cap_packets.ConfigurationResponseResult.UNACCEPTABLE_PARAMETERS)

    @metadata(pts_test_id="L2CAP/COS/CFD/BV-12-C", pts_test_name="Unknown Option Response")
    def test_config_unknown_options_with_hint(self):
        """
        Verify that the IUT can give the appropriate error code when the Lower
        Tester proposes any number of unknown options that are optional
        NOTE: In GD stack, ExtendedWindowSizeOption in unsupported
        """
        self._setup_link_from_cert()

        (dut_channel, cert_channel) = self._open_unconfigured_channel_from_cert()

        unknown_opt_hint = l2cap_packets.ExtendedWindowSizeOption()
        unknown_opt_hint.max_window_size = 20
        unknown_opt_hint.is_hint = l2cap_packets.ConfigurationOptionIsHint.OPTION_IS_A_HINT

        for i in range(10):
            cert_channel.send_configure_request([unknown_opt_hint] * i)
            cert_channel.verify_configuration_response(l2cap_packets.ConfigurationResponseResult.SUCCESS)

    @metadata(pts_test_id="L2CAP/COS/CFD/BV-14-C", pts_test_name="Unknown Mandatory Options Request")
    def test_unknown_mandatory_options_request(self):
        """
        Verify that the IUT can give the appropriate error code when the Lower
        Tester proposes any number of unknown options where at least one is
        mandatory.
        Note: GD stack doesn't support extended window size. For other stacks,
              we may need to use some other config option
        """
        self._setup_link_from_cert()

        (dut_channel, cert_channel) = self._open_unconfigured_channel_from_cert(scid=0x41, psm=0x33)

        unknown_opt = l2cap_packets.ExtendedWindowSizeOption()
        unknown_opt.max_window_size = 20

        unknown_opt_hint = l2cap_packets.ExtendedWindowSizeOption()
        unknown_opt_hint.max_window_size = 20
        unknown_opt_hint.is_hint = l2cap_packets.ConfigurationOptionIsHint.OPTION_IS_A_HINT

        configuration_option_attempts = [[unknown_opt], [unknown_opt, unknown_opt_hint], [
            unknown_opt, unknown_opt, unknown_opt
        ], [unknown_opt, unknown_opt_hint, unknown_opt_hint,
            unknown_opt], [unknown_opt_hint, unknown_opt_hint, unknown_opt_hint, unknown_opt_hint, unknown_opt], [
                unknown_opt, unknown_opt_hint, unknown_opt_hint, unknown_opt, unknown_opt_hint, unknown_opt_hint
            ], [unknown_opt, unknown_opt, unknown_opt, unknown_opt, unknown_opt, unknown_opt, unknown_opt], [
                unknown_opt_hint, unknown_opt_hint, unknown_opt_hint, unknown_opt_hint, unknown_opt_hint,
                unknown_opt_hint, unknown_opt_hint, unknown_opt
            ], [
                unknown_opt_hint, unknown_opt_hint, unknown_opt_hint, unknown_opt_hint, unknown_opt_hint,
                unknown_opt_hint, unknown_opt_hint, unknown_opt, unknown_opt
            ], [
                unknown_opt_hint, unknown_opt_hint, unknown_opt_hint, unknown_opt_hint, unknown_opt_hint,
                unknown_opt_hint, unknown_opt_hint, unknown_opt_hint, unknown_opt_hint, unknown_opt
            ]]

        for option_list in configuration_option_attempts:
            cert_channel.send_configure_request(option_list)
            cert_channel.verify_configuration_response(l2cap_packets.ConfigurationResponseResult.UNKNOWN_OPTIONS)

    @metadata(pts_test_id="L2CAP/COS/ECH/BV-01-C", pts_test_name="Respond to Echo Request")
    def test_respond_to_echo_request(self):
        """
        Verify that the IUT responds to an echo request.
        """
        self._setup_link_from_cert()
        echo_request = l2cap_packets.EchoRequestBuilder(100, RawBuilder([1, 2, 3]))
        self.cert_l2cap.get_control_channel().send(echo_request)

        assertThat(self.cert_l2cap.get_control_channel()).emits(L2capMatchers.EchoResponse())

    @metadata(pts_test_id="L2CAP/COS/CED/BI-01-C", pts_test_name="Reject Unknown Command")
    def test_reject_unknown_command(self):
        """
        Verify that the IUT rejects an unknown signaling command
        """
        self._setup_link_from_cert()

        # Command code ff, Signal id 01, size 0000
        invalid_command_packet = RawBuilder([0xff, 0x01, 0x00, 0x00])
        self.cert_l2cap.get_control_channel().send(invalid_command_packet)

        assertThat(self.cert_l2cap.get_control_channel()).emits(L2capMatchers.CommandReject())

    @metadata(pts_test_id="L2CAP/COS/IEX/BV-01-C", pts_test_name="Query for 1.2 Features")
    def test_query_for_1_2_features(self):
        """
        Verify that the IUT transmits an information request command to solicit
        if the remote device supports Specification 1.2 features.
        """
        self._setup_link_from_cert()
        assertThat(self.cert_l2cap.get_control_channel()).emits(
            L2capMatchers.InformationRequestWithType(
                l2cap_packets.InformationRequestInfoType.EXTENDED_FEATURES_SUPPORTED))

    @metadata(pts_test_id="L2CAP/COS/IEX/BV-02-C", pts_test_name="Respond with 1.2 Features")
    def test_respond_with_1_2_features(self):
        """
        Verify that the IUT responds to an information request command
        soliciting for Specification 1.2 features
        """
        self._setup_link_from_cert()
        control_channel = self.cert_l2cap.get_control_channel()

        control_channel.send_extended_features_request()

        assertThat(control_channel).emits(L2capMatchers.InformationResponseExtendedFeatures())

    @metadata(
        pts_test_id="L2CAP/EXF/BV-01-C",
        pts_test_name="Extended Features Information Response for "
        "Enhanced Retransmission Mode")
    def test_extended_feature_info_response_ertm(self):
        """
        Verify the IUT can format an Information Response for the information
        type of Extended Features that correctly identifies that Enhanced
        Retransmission Mode is locally supported
        """
        self._setup_link_from_cert()
        control_channel = self.cert_l2cap.get_control_channel()

        control_channel.send_extended_features_request()

        assertThat(control_channel).emits(L2capMatchers.InformationResponseExtendedFeatures(supports_ertm=True))

    @metadata(
        pts_test_id="L2CAP/EXF/BV-02-C", pts_test_name="Extended Features Information Response for "
        "Streaming Mode")
    def test_extended_feature_info_response_streaming(self):
        """
        Verify the IUT can format an Information Response for the information
        type of Extended Features that correctly identifies that Streaming Mode
        is locally supported
        """
        asserts.skip("Streaming not supported")
        self._setup_link_from_cert()
        control_channel = self.cert_l2cap.get_control_channel()

        control_channel.send_extended_features_request()

        assertThat(control_channel).emits(L2capMatchers.InformationResponseExtendedFeatures(supports_streaming=True))

    @metadata(pts_test_id="L2CAP/EXF/BV-03-C", pts_test_name="Extended Features Information Response for FCS " "Option")
    def test_extended_feature_info_response_fcs(self):
        """
        Verify the IUT can format an Information Response for the information
        type of Extended Features that correctly identifies that the FCS Option
        is locally supported.

        Note: This is not mandated by L2CAP Spec
        """
        self._setup_link_from_cert()
        control_channel = self.cert_l2cap.get_control_channel()

        control_channel.send_extended_features_request()

        assertThat(control_channel).emits(L2capMatchers.InformationResponseExtendedFeatures(supports_fcs=True))

    @metadata(
        pts_test_id="L2CAP/EXF/BV-05-C", pts_test_name="Extended Features Information Response for Fixed "
        "Channels")
    def test_extended_feature_info_response_fixed_channels(self):
        """
        Verify the IUT can format an Information Response for the information
        type of Extended Features that correctly identifies that the Fixed
        Channels option is locally supported

        Note: This is not mandated by L2CAP Spec
        """
        self._setup_link_from_cert()
        control_channel = self.cert_l2cap.get_control_channel()

        control_channel.send_extended_features_request()

        assertThat(control_channel).emits(
            L2capMatchers.InformationResponseExtendedFeatures(supports_fixed_channels=True))

    @metadata(pts_test_id="L2CAP/FIX/BV-01-C", pts_test_name="Fixed Channels Supported Information Request")
    def test_fixed_channels_supported_information_request(self):
        """
        Verify that the IUT can send an Information Request for the information
        type of Fixed Channels Supported.
        """
        self._setup_link_from_cert()
        assertThat(self.cert_l2cap.get_control_channel()).emits(
            L2capMatchers.InformationRequestWithType(l2cap_packets.InformationRequestInfoType.FIXED_CHANNELS_SUPPORTED))

    @metadata(pts_test_id="L2CAP/FOC/BV-01-C", pts_test_name="IUT Initiated Configuration of the FCS Option")
    def test_config_channel_not_use_FCS(self):
        """
        Verify the IUT can configure a channel to not use FCS in I/S-frames.
        """
        self._setup_link_from_cert()

        (dut_channel, cert_channel) = self._open_channel_from_cert(
            mode=RetransmissionFlowControlMode.ERTM, fcs=FcsType.NO_FCS)

        dut_channel.send(b'abc')
        assertThat(cert_channel).emits(L2capMatchers.IFrame(tx_seq=0, payload=b'abc'))

    @metadata(pts_test_id="L2CAP/FOC/BV-02-C", pts_test_name="Lower Tester Explicitly Requests FCS should be " "Used")
    def test_explicitly_request_use_FCS(self):
        """
        Verify the IUT will include the FCS in I/S-frames if the Lower Tester
        explicitly requests that FCS should be used
        """
        self._setup_link_from_cert()

        (dut_channel, cert_channel) = self._open_channel_from_cert(
            mode=RetransmissionFlowControlMode.ERTM, fcs=FcsType.DEFAULT)

        dut_channel.send(b'abc')
        assertThat(cert_channel).emits(L2capMatchers.IFrameWithFcs(payload=b"abc"))

    @metadata(pts_test_id="L2CAP/FOC/BV-03-C", pts_test_name="Lower Tester Implicitly Requests FCS should be " "Used")
    def test_implicitly_request_use_FCS(self):
        """
        Verify the IUT will include the FCS in I/S-frames if the Lower Tester
        implicitly requests that FCS should be used.
        """
        self._setup_link_from_cert()

        (dut_channel, cert_channel) = self._open_channel_from_cert(
            mode=RetransmissionFlowControlMode.ERTM,
            fcs=FcsType.DEFAULT,
            req_config_options=CertL2cap.config_option_ertm(fcs=FcsType.NO_FCS))

        dut_channel.send(b'abc')
        assertThat(cert_channel).emits(L2capMatchers.IFrameWithFcs(payload=b"abc"))

    @metadata(pts_test_id="L2CAP/OFS/BV-01-C", pts_test_name="Sending I-Frames without FCS for ERTM")
    def test_sending_i_frames_without_fcs_for_ertm(self):
        """
        Verify the IUT does not include the FCS in I-frames.
        """
        self._setup_link_from_cert()

        (dut_channel, cert_channel) = self._open_channel_from_cert(
            mode=RetransmissionFlowControlMode.ERTM, fcs=FcsType.NO_FCS)

        dut_channel.send(b'abc')
        assertThat(cert_channel).emits(L2capMatchers.IFrame(tx_seq=0, payload=b"abc"))

    @metadata(pts_test_id="L2CAP/OFS/BV-02-C", pts_test_name="Receiving I-Frames without FCS for ERTM")
    def test_receiving_i_frames_without_fcs_for_ertm(self):
        """
        Verify the IUT can handle I-frames that do not contain the FCS.
        """
        self._setup_link_from_cert()

        (dut_channel, cert_channel) = self._open_channel_from_cert(
            mode=RetransmissionFlowControlMode.ERTM, fcs=FcsType.NO_FCS)

        cert_channel.send_i_frame(tx_seq=0, req_seq=0, payload=SAMPLE_PACKET)
        assertThat(dut_channel).emits(L2capMatchers.PacketPayloadRawData(SAMPLE_PACKET_DATA))

    @metadata(pts_test_id="L2CAP/OFS/BV-05-C", pts_test_name="Sending I-Frames with FCS for ERTM")
    def test_sending_i_frames_with_fcs_for_ertm(self):
        """
        Verify the IUT does include the FCS in I-frames.
        """
        self._setup_link_from_cert()

        (dut_channel, cert_channel) = self._open_channel_from_cert(
            mode=RetransmissionFlowControlMode.ERTM, fcs=FcsType.DEFAULT)

        dut_channel.send(b'abc')
        assertThat(cert_channel).emits(L2capMatchers.IFrameWithFcs(tx_seq=0, payload=b"abc"))

    @metadata(pts_test_id="L2CAP/OFS/BV-06-C", pts_test_name="Receiving I-Frames with FCS for ERTM")
    def test_receiving_i_frames_with_fcs_for_ertm(self):
        """
        Verify the IUT can handle I-frames that do contain the FCS.
        """
        self._setup_link_from_cert()

        (dut_channel, cert_channel) = self._open_channel_from_cert(
            mode=RetransmissionFlowControlMode.ERTM, fcs=FcsType.DEFAULT)

        cert_channel.send_i_frame(tx_seq=0, req_seq=0, payload=SAMPLE_PACKET, fcs=FcsType.DEFAULT)
        assertThat(dut_channel).emits(L2capMatchers.PacketPayloadRawData(SAMPLE_PACKET_DATA))

    @metadata(pts_test_id="L2CAP/ERM/BV-01-C", pts_test_name="Transmit I-frames")
    def test_transmit_i_frames(self):
        """
        Verify the IUT can send correctly formatted sequential I-frames with
        valid values for the enhanced control fields (SAR, F-bit, ReqSeq,
        TxSeq)
        """
        self._setup_link_from_cert()

        (dut_channel, cert_channel) = self._open_channel_from_cert(
            mode=RetransmissionFlowControlMode.ERTM, fcs=FcsType.NO_FCS)

        dut_channel.send(b'abc')
        assertThat(cert_channel).emits(L2capMatchers.IFrame(tx_seq=0, payload=b"abc"))

        cert_channel.send_i_frame(tx_seq=0, req_seq=1, payload=SAMPLE_PACKET)

        dut_channel.send(b'abc')
        assertThat(cert_channel).emits(L2capMatchers.IFrame(tx_seq=1, payload=b"abc"))

        cert_channel.send_i_frame(tx_seq=1, req_seq=2, payload=SAMPLE_PACKET)

        dut_channel.send(b'abc')
        assertThat(cert_channel).emits(L2capMatchers.PartialData(b"abc"))

        cert_channel.send_i_frame(tx_seq=2, req_seq=3, payload=SAMPLE_PACKET)

    @metadata(pts_test_id="L2CAP/ERM/BV-02-C", pts_test_name="Receive I-Frames")
    def test_receive_i_frames(self):
        """
        Verify the IUT can receive in-sequence valid I-frames and deliver L2CAP
        SDUs to the Upper Tester
        """
        self._setup_link_from_cert()

        (dut_channel, cert_channel) = self._open_channel_from_cert(
            mode=RetransmissionFlowControlMode.ERTM, fcs=FcsType.NO_FCS)

        for i in range(3):
            cert_channel.send_i_frame(tx_seq=i, req_seq=0, payload=SAMPLE_PACKET)
            assertThat(cert_channel).emits(L2capMatchers.SFrame(req_seq=i + 1))

        cert_channel.send_i_frame(tx_seq=3, req_seq=0, sar=SegmentationAndReassembly.START, payload=SAMPLE_PACKET)
        assertThat(cert_channel).emits(L2capMatchers.SFrame(req_seq=4))

        cert_channel.send_i_frame(
            tx_seq=4, req_seq=0, sar=SegmentationAndReassembly.CONTINUATION, payload=SAMPLE_PACKET)
        assertThat(cert_channel).emits(L2capMatchers.SFrame(req_seq=5))

        cert_channel.send_i_frame(tx_seq=5, req_seq=0, sar=SegmentationAndReassembly.END, payload=SAMPLE_PACKET)
        assertThat(cert_channel).emits(L2capMatchers.SFrame(req_seq=6))

    @metadata(pts_test_id="L2CAP/ERM/BV-03-C", pts_test_name="Acknowledging Received I-Frames")
    def test_acknowledging_received_i_frames(self):
        """
        Verify the IUT sends S-frame [RR] with the Poll bit not set to
        acknowledge data received from the Lower Tester
        """
        self._setup_link_from_cert()

        (dut_channel, cert_channel) = self._open_channel_from_cert(
            mode=RetransmissionFlowControlMode.ERTM, fcs=FcsType.NO_FCS)

        for i in range(3):
            cert_channel.send_i_frame(tx_seq=i, req_seq=0, payload=SAMPLE_PACKET)
            assertThat(cert_channel).emits(L2capMatchers.SFrame(req_seq=i + 1))

        assertThat(cert_channel).emitsNone(L2capMatchers.SFrame(req_seq=4), timeout=timedelta(seconds=1))

    @metadata(
        pts_test_id="L2CAP/ERM/BV-05-C",
        pts_test_name="Resume Transmitting I-Frames when an S-Frame [RR] "
        "is Received")
    def test_resume_transmitting_when_received_rr(self):
        """
        Verify the IUT will cease transmission of I-frames when the negotiated
        TxWindow is full. Verify the IUT will resume transmission of I-frames
        when an S-frame [RR] is received that acknowledges previously sent
        I-frames
        """
        self._setup_link_from_cert()

        config = CertL2cap.config_option_ertm(fcs=FcsType.NO_FCS, tx_window_size=1)

        (dut_channel, cert_channel) = self._open_channel_from_cert(
            mode=RetransmissionFlowControlMode.ERTM, req_config_options=config, rsp_config_options=config)

        dut_channel.send(b'abc')
        dut_channel.send(b'def')

        assertThat(cert_channel).emits(L2capMatchers.IFrame(tx_seq=0, payload=b'abc'))
        assertThat(cert_channel).emitsNone(L2capMatchers.IFrame(tx_seq=1, payload=b'def'))

        cert_channel.send_s_frame(req_seq=1, f=Final.POLL_RESPONSE)
        assertThat(cert_channel).emits(L2capMatchers.IFrame(tx_seq=1))

    @metadata(
        pts_test_id="L2CAP/ERM/BV-06-C", pts_test_name="Resume Transmitting I-Frames when an I-Frame is "
        "Received")
    def test_resume_transmitting_when_acknowledge_previously_sent(self):
        """
        Verify the IUT will cease transmission of I-frames when the negotiated
        TxWindow is full. Verify the IUT will resume transmission of I-frames
        when an I-frame is received that acknowledges previously sent I-frames
        """
        self._setup_link_from_cert()

        config = CertL2cap.config_option_ertm(fcs=FcsType.NO_FCS, tx_window_size=1)

        (dut_channel, cert_channel) = self._open_channel_from_cert(
            mode=RetransmissionFlowControlMode.ERTM, req_config_options=config, rsp_config_options=config)

        dut_channel.send(b'abc')
        dut_channel.send(b'def')

        assertThat(cert_channel).emits(L2capMatchers.IFrame(tx_seq=0, payload=b'abc'))
        assertThat(cert_channel).emitsNone(
            L2capMatchers.IFrame(tx_seq=1, payload=b'abc'), timeout=timedelta(seconds=0.5))

        cert_channel.send_i_frame(tx_seq=0, req_seq=1, payload=SAMPLE_PACKET)

        assertThat(cert_channel).emits(L2capMatchers.IFrame(tx_seq=1, payload=b'def'))

        cert_channel.send_i_frame(tx_seq=1, req_seq=2, payload=SAMPLE_PACKET)

    @metadata(pts_test_id="L2CAP/ERM/BV-07-C", pts_test_name="Send S-Frame [RNR]")
    def test_send_s_frame_rnr(self):
        """
        Verify the IUT sends an S-frame [RNR] when it detects local busy condition
        NOTE: In GD stack, we enter local busy condition if client doesn't dequeue
        and packets are accumulating in buffer
        """
        self._setup_link_from_cert()

        config = CertL2cap.config_option_ertm(fcs=FcsType.NO_FCS, tx_window_size=10)

        (dut_channel, cert_channel) = self._open_channel_from_cert(
            mode=RetransmissionFlowControlMode.ERTM,
            fcs=FcsType.NO_FCS,
            req_config_options=config,
            rsp_config_options=config)

        dut_channel.send(b'abc')
        assertThat(cert_channel).emits(L2capMatchers.IFrame(tx_seq=0, payload=b'abc'))
        cert_channel.send_i_frame(tx_seq=0, req_seq=1, payload=SAMPLE_PACKET)

        dut_channel.set_traffic_paused(True)

        # Allow 1 additional packet in channel queue buffer
        buffer_size = self.dut_l2cap.get_channel_queue_buffer_size() + 1

        for i in range(buffer_size):
            cert_channel.send_i_frame(tx_seq=i + 1, req_seq=1, payload=SAMPLE_PACKET)
            assertThat(cert_channel).emits(L2capMatchers.SFrame(s=l2cap_packets.SupervisoryFunction.RECEIVER_READY))

        cert_channel.send_i_frame(tx_seq=buffer_size + 1, req_seq=1, payload=SAMPLE_PACKET)
        assertThat(cert_channel).emits(L2capMatchers.SFrame(s=l2cap_packets.SupervisoryFunction.RECEIVER_NOT_READY))

    @metadata(pts_test_id="L2CAP/ERM/BV-08-C", pts_test_name="Send S-Frame [RR] with Poll Bit Set")
    def test_transmit_s_frame_rr_with_poll_bit_set(self):
        """
        Verify the IUT sends an S-frame [RR] with the Poll bit set when its
        retransmission timer expires.
        """
        self._setup_link_from_cert()

        config = CertL2cap.config_option_ertm(fcs=FcsType.NO_FCS, retransmission_time_out=1500)

        (dut_channel, cert_channel) = self._open_channel_from_cert(
            mode=RetransmissionFlowControlMode.ERTM,
            fcs=FcsType.NO_FCS,
            req_config_options=config,
            rsp_config_options=config)

        dut_channel.send(b'abc')
        assertThat(cert_channel).emits(L2capMatchers.SFrame(p=l2cap_packets.Poll.POLL))

    @metadata(pts_test_id="L2CAP/ERM/BV-09-C", pts_test_name="Send S-Frame [RR] with Final Bit Set")
    def test_transmit_s_frame_rr_with_final_bit_set(self):
        """
        Verify the IUT responds with an S-frame [RR] with the Final bit set
        after receiving an S-frame [RR] with the Poll bit set
        """
        self._setup_link_from_cert()

        (dut_channel, cert_channel) = self._open_channel_from_cert(
            mode=RetransmissionFlowControlMode.ERTM, fcs=FcsType.NO_FCS)

        cert_channel.send_s_frame(req_seq=0, p=Poll.POLL)
        assertThat(cert_channel).emits(L2capMatchers.SFrame(f=Final.POLL_RESPONSE))

    @metadata(pts_test_id="L2CAP/ERM/BV-10-C", pts_test_name="Retransmit S-Frame [RR] with Final Bit Set")
    def test_retransmit_s_frame_rr_with_poll_bit_set(self):
        """
        Verify the IUT will retransmit the S-frame [RR] with the Poll bit set
        when the Monitor Timer expires
        """
        self._setup_link_from_cert()

        (dut_channel, cert_channel) = self._open_channel_from_cert(
            mode=RetransmissionFlowControlMode.ERTM, fcs=FcsType.NO_FCS)
        dut_channel.send(b'abc')

        assertThat(cert_channel).emits(L2capMatchers.IFrame(tx_seq=0, payload=b'abc'))
        assertThat(cert_channel).emits(L2capMatchers.SFrame(req_seq=0, p=Poll.POLL, f=Final.NOT_SET))
        cert_channel.send_s_frame(req_seq=1, f=Final.POLL_RESPONSE)

    @metadata(pts_test_id="L2CAP/ERM/BV-11-C", pts_test_name="S-Frame Transmissions Exceed MaxTransmit")
    def test_s_frame_transmissions_exceed_max_transmit(self):
        """
        Verify the IUT will close the channel when the Monitor Timer expires.
        """
        self._setup_link_from_cert()

        config = CertL2cap.config_option_ertm(fcs=FcsType.NO_FCS, tx_window_size=1, max_transmit=1, monitor_time_out=10)

        (dut_channel, cert_channel) = self._open_channel_from_cert(
            mode=RetransmissionFlowControlMode.ERTM, req_config_options=config, rsp_config_options=config)

        dut_channel.send(b'abc')
        cert_channel.verify_disconnect_request()

    @metadata(pts_test_id="L2CAP/ERM/BV-12-C", pts_test_name="I-Frame Transmissions Exceed MaxTransmit")
    def test_i_frame_transmissions_exceed_max_transmit(self):
        """
        Verify the IUT will close the channel when it receives an S-frame [RR]
        with the final bit set that does not acknowledge the previous I-frame
        sent by the IUT
        """
        self._setup_link_from_cert()

        config = CertL2cap.config_option_ertm(fcs=FcsType.NO_FCS, tx_window_size=1, max_transmit=1)

        (dut_channel, cert_channel) = self._open_channel_from_cert(
            mode=RetransmissionFlowControlMode.ERTM, req_config_options=config, rsp_config_options=config)

        dut_channel.send(b'abc')
        assertThat(cert_channel).emits(L2capMatchers.IFrame(tx_seq=0), L2capMatchers.SFrame(p=Poll.POLL)).inOrder()

        cert_channel.send_s_frame(req_seq=0, f=Final.POLL_RESPONSE)
        cert_channel.verify_disconnect_request()

    @metadata(pts_test_id="L2CAP/ERM/BV-13-C", pts_test_name="Respond to S-Frame [REJ]")
    def test_respond_to_rej(self):
        """
        Verify the IUT retransmits I-frames starting from the sequence number
        specified in the S-frame [REJ]
        """
        self._setup_link_from_cert()

        config = CertL2cap.config_option_ertm(fcs=FcsType.NO_FCS, tx_window_size=2, max_transmit=2)

        (dut_channel, cert_channel) = self._open_channel_from_cert(
            mode=RetransmissionFlowControlMode.ERTM, req_config_options=config, rsp_config_options=config)

        dut_channel.send(b'abc')
        dut_channel.send(b'abc')
        assertThat(cert_channel).emits(
            L2capMatchers.IFrame(tx_seq=0, payload=b'abc'), L2capMatchers.IFrame(tx_seq=1, payload=b'abc')).inOrder()

        cert_channel.send_s_frame(req_seq=0, s=SupervisoryFunction.REJECT)

        assertThat(cert_channel).emits(
            L2capMatchers.IFrame(tx_seq=0, payload=b'abc'), L2capMatchers.IFrame(tx_seq=1, payload=b'abc')).inOrder()

    @metadata(pts_test_id="L2CAP/ERM/BV-14-C", pts_test_name="Respond to S-Frame [SREJ] POLL Bit Set")
    def test_respond_to_srej_p_set(self):
        """
        Verify the IUT responds with the correct I-frame when sent an SREJ
        frame. Verify that the IUT processes the acknowledgment of previously
        unacknowledged I-frames
        """
        self._setup_link_from_cert()

        config = CertL2cap.config_option_ertm(fcs=FcsType.NO_FCS, max_transmit=2, tx_window_size=3)

        (dut_channel, cert_channel) = self._open_channel_from_cert(
            mode=RetransmissionFlowControlMode.ERTM, req_config_options=config, rsp_config_options=config)

        for _ in range(4):
            dut_channel.send(b'abc')
        assertThat(cert_channel).emits(
            L2capMatchers.IFrame(tx_seq=0, payload=b'abc'), L2capMatchers.IFrame(tx_seq=1, payload=b'abc'),
            L2capMatchers.IFrame(tx_seq=2, payload=b'abc')).inOrder()

        cert_channel.send_s_frame(req_seq=1, p=Poll.POLL, s=SupervisoryFunction.SELECT_REJECT)

        assertThat(cert_channel).emits(
            L2capMatchers.IFrame(tx_seq=1, payload=b'abc', f=Final.POLL_RESPONSE),
            L2capMatchers.IFrame(tx_seq=3, payload=b'abc')).inOrder()

    @metadata(pts_test_id="L2CAP/ERM/BV-15-C", pts_test_name="Respond to S-Frame [SREJ] POLL Bit Clear")
    def test_respond_to_srej_p_clear(self):
        """
        Verify the IUT responds with the correct I-frame when sent an SREJ frame
        """
        self._setup_link_from_cert()

        config = CertL2cap.config_option_ertm(fcs=FcsType.NO_FCS, max_transmit=2, tx_window_size=3)
        (dut_channel, cert_channel) = self._open_channel_from_cert(
            mode=RetransmissionFlowControlMode.ERTM, req_config_options=config, rsp_config_options=config)

        for _ in range(4):
            dut_channel.send(b'abc')
        assertThat(cert_channel).emits(
            L2capMatchers.IFrame(tx_seq=0, payload=b'abc'), L2capMatchers.IFrame(tx_seq=1, payload=b'abc'),
            L2capMatchers.IFrame(tx_seq=2, payload=b'abc')).inOrder()

        cert_channel.send_s_frame(req_seq=1, s=SupervisoryFunction.SELECT_REJECT)
        assertThat(cert_channel).emits(L2capMatchers.IFrame(tx_seq=1, payload=b'abc', f=Final.NOT_SET))
        cert_channel.send_s_frame(req_seq=3, s=SupervisoryFunction.RECEIVER_READY)
        assertThat(cert_channel).emits(L2capMatchers.IFrame(tx_seq=3, payload=b'abc', f=Final.NOT_SET))

    @metadata(pts_test_id="L2CAP/ERM/BV-16-C", pts_test_name="Send S-Frame [REJ]")
    def test_send_s_frame_rej(self):
        """
        Verify the IUT can send an S-Frame [REJ] after receiving out of sequence
        I-Frames
        """
        self._setup_link_from_cert()
        tx_window_size = 4

        config = CertL2cap.config_option_ertm(fcs=FcsType.NO_FCS, tx_window_size=tx_window_size)
        (dut_channel, cert_channel) = self._open_channel_from_cert(
            mode=RetransmissionFlowControlMode.ERTM, req_config_options=config, rsp_config_options=config)

        cert_channel.send_i_frame(tx_seq=0, req_seq=0, f=Final.NOT_SET, payload=SAMPLE_PACKET)
        cert_channel.send_i_frame(tx_seq=2, req_seq=0, f=Final.NOT_SET, payload=SAMPLE_PACKET)

        assertThat(cert_channel).emits(
            L2capMatchers.SFrame(req_seq=1, f=Final.NOT_SET, s=SupervisoryFunction.REJECT, p=Poll.NOT_SET))

        for i in range(1, tx_window_size):
            cert_channel.send_i_frame(tx_seq=i, req_seq=0, f=Final.NOT_SET, payload=SAMPLE_PACKET)
        assertThat(cert_channel).emits(
            L2capMatchers.SFrame(req_seq=i + 1, f=Final.NOT_SET, s=SupervisoryFunction.RECEIVER_READY))

    @metadata(pts_test_id="L2CAP/ERM/BV-18-C", pts_test_name="Receive S-Frame [RR] Final Bit = 1")
    def test_receive_s_frame_rr_final_bit_set(self):
        """
        Verify the IUT will retransmit any previously sent I-frames
        unacknowledged by receipt of an S-Frame [RR] with the Final Bit set
        """
        self._setup_link_from_cert()

        config = CertL2cap.config_option_ertm(fcs=FcsType.NO_FCS, retransmission_time_out=1500)

        (dut_channel, cert_channel) = self._open_channel_from_cert(
            mode=RetransmissionFlowControlMode.ERTM, req_config_options=config, rsp_config_options=config)

        dut_channel.send(b'abc')

        assertThat(cert_channel).emits(L2capMatchers.SFrame(p=l2cap_packets.Poll.POLL))

        cert_channel.send_s_frame(req_seq=0, f=Final.POLL_RESPONSE)
        assertThat(cert_channel).emits(L2capMatchers.IFrame(tx_seq=0))

    @metadata(pts_test_id="L2CAP/ERM/BV-19-C", pts_test_name="Receive I-Frame Final Bit = 1")
    def test_receive_i_frame_final_bit_set(self):
        """
        Verify the IUT will retransmit any previously sent I-frames
        unacknowledged by receipt of an I-frame with the final bit set
        """
        self._setup_link_from_cert()

        config = CertL2cap.config_option_ertm(fcs=FcsType.NO_FCS, retransmission_time_out=1500)
        (dut_channel, cert_channel) = self._open_channel_from_cert(
            mode=RetransmissionFlowControlMode.ERTM, req_config_options=config, rsp_config_options=config)

        dut_channel.send(b'abc')
        assertThat(cert_channel).emits(L2capMatchers.SFrame(p=Poll.POLL))

        cert_channel.send_i_frame(tx_seq=0, req_seq=0, f=Final.POLL_RESPONSE, payload=SAMPLE_PACKET)
        assertThat(cert_channel).emits(L2capMatchers.IFrame(tx_seq=0))

    @metadata(pts_test_id="L2CAP/ERM/BV-20-C", pts_test_name="Enter Remote Busy Condition")
    def test_receive_rnr(self):
        """
        Verify the IUT will not retransmit any I-frames when it receives a
        remote busy indication from the Lower Tester (S-frame [RNR])
        """
        self._setup_link_from_cert()

        config = CertL2cap.config_option_ertm(fcs=FcsType.NO_FCS, retransmission_time_out=1500)
        (dut_channel, cert_channel) = self._open_channel_from_cert(
            mode=RetransmissionFlowControlMode.ERTM, req_config_options=config, rsp_config_options=config)

        dut_channel.send(b'abc')
        assertThat(cert_channel).emits(L2capMatchers.SFrame(p=l2cap_packets.Poll.POLL))

        cert_channel.send_s_frame(req_seq=0, s=SupervisoryFunction.RECEIVER_NOT_READY, f=Final.POLL_RESPONSE)
        assertThat(cert_channel).emitsNone(L2capMatchers.IFrame(tx_seq=0))

    @metadata(pts_test_id="L2CAP/ERM/BV-22-C", pts_test_name="Exit Local Busy Condition")
    def test_exit_local_busy_condition(self):
        """
        Verify the IUT sends an S-frame [RR] Poll = 1 when the local busy condition is cleared
        NOTE: In GD stack, we enter local busy condition if client doesn't dequeue
        and packets are accumulating in buffer
        """
        self._setup_link_from_cert()

        config = CertL2cap.config_option_ertm(fcs=FcsType.NO_FCS, tx_window_size=10)

        (dut_channel, cert_channel) = self._open_channel_from_cert(
            mode=RetransmissionFlowControlMode.ERTM,
            fcs=FcsType.NO_FCS,
            req_config_options=config,
            rsp_config_options=config)

        dut_channel.send(b'abc')
        assertThat(cert_channel).emits(L2capMatchers.IFrame(tx_seq=0, payload=b'abc'))
        cert_channel.send_i_frame(tx_seq=0, req_seq=1, payload=SAMPLE_PACKET)

        dut_channel.set_traffic_paused(True)

        # Allow 1 additional packet in channel queue buffer
        buffer_size = self.dut_l2cap.get_channel_queue_buffer_size() + 1

        for i in range(buffer_size):
            cert_channel.send_i_frame(tx_seq=i + 1, req_seq=1, payload=SAMPLE_PACKET)
            assertThat(cert_channel).emits(L2capMatchers.SFrame(s=l2cap_packets.SupervisoryFunction.RECEIVER_READY))

        cert_channel.send_i_frame(tx_seq=buffer_size + 1, req_seq=1, payload=SAMPLE_PACKET)
        assertThat(cert_channel).emits(L2capMatchers.SFrame(s=l2cap_packets.SupervisoryFunction.RECEIVER_NOT_READY))

        dut_channel.set_traffic_paused(False)
        assertThat(cert_channel).emits(
            L2capMatchers.SFrame(s=l2cap_packets.SupervisoryFunction.RECEIVER_READY, p=l2cap_packets.Poll.POLL))
        cert_channel.send_s_frame(1, f=l2cap_packets.Final.POLL_RESPONSE)

    @metadata(pts_test_id="L2CAP/ERM/BV-23-C", pts_test_name="Transmit I-Frames using SAR")
    def test_transmit_i_frames_using_sar(self):
        """
        Verify the IUT can send correctly formatted sequential I-frames with
        valid values for the enhanced control fields (SAR, F-bit, ReqSeq,
        TxSeq) when performing SAR.
        """
        self._setup_link_from_cert()

        config = CertL2cap.config_option_ertm(fcs=FcsType.NO_FCS, mps=11)
        (dut_channel, cert_channel) = self._open_channel_from_cert(
            mode=RetransmissionFlowControlMode.ERTM, req_config_options=config, rsp_config_options=config)

        dut_channel.send(b'abcabcabc')
        # First IFrame should contain SDU size after control field
        assertThat(cert_channel).emits(
            L2capMatchers.IFrameStart(tx_seq=0, payload=b'abc'), L2capMatchers.IFrame(tx_seq=1, payload=b'abc'),
            L2capMatchers.IFrame(tx_seq=2, payload=b'abc')).inOrder()

        cert_channel.send_s_frame(req_seq=3, s=SupervisoryFunction.RECEIVER_READY)

        dut_channel.send(b'defdefdef')
        # First IFrame should contain SDU size after control field
        assertThat(cert_channel).emits(
            L2capMatchers.IFrameStart(tx_seq=3, payload=b'def'), L2capMatchers.IFrame(tx_seq=4, payload=b'def'),
            L2capMatchers.IFrame(tx_seq=5, payload=b'def')).inOrder()

    @metadata(pts_test_id="L2CAP/ERM/BI-01-C", pts_test_name="S-Frame [REJ] Lost or Corrupted")
    def test_sent_rej_lost(self):
        """
        Verify the IUT can handle receipt of an S-=frame [RR] Poll = 1 if the
        S-frame [REJ] sent from the IUT is lost
        """
        self._setup_link_from_cert()
        ertm_tx_window_size = 5

        config = CertL2cap.config_option_ertm(fcs=FcsType.NO_FCS, tx_window_size=ertm_tx_window_size)
        (dut_channel, cert_channel) = self._open_channel_from_cert(
            mode=RetransmissionFlowControlMode.ERTM, req_config_options=config, rsp_config_options=config)

        cert_channel.send_i_frame(tx_seq=0, req_seq=0, payload=SAMPLE_PACKET)
        assertThat(cert_channel).emits(L2capMatchers.SFrame(req_seq=1))

        cert_channel.send_i_frame(tx_seq=ertm_tx_window_size - 1, req_seq=0, payload=SAMPLE_PACKET)
        assertThat(cert_channel).emits(L2capMatchers.SFrame(s=SupervisoryFunction.REJECT))

        cert_channel.send_s_frame(req_seq=0, p=Poll.POLL)

        assertThat(cert_channel).emits(L2capMatchers.SFrame(req_seq=1, f=l2cap_packets.Final.POLL_RESPONSE))
        for i in range(1, ertm_tx_window_size):
            cert_channel.send_i_frame(tx_seq=i, req_seq=0, payload=SAMPLE_PACKET)
            assertThat(cert_channel).emits(L2capMatchers.SFrame(req_seq=i + 1))

    @metadata(pts_test_id="L2CAP/ERM/BI-03-C", pts_test_name="Handle Duplicate S-Frame [SREJ]")
    def test_handle_duplicate_srej(self):
        """
        Verify the IUT will only retransmit the requested I-frame once after
        receiving a duplicate SREJ
        """
        self._setup_link_from_cert()

        (dut_channel, cert_channel) = self._open_channel_from_cert(
            mode=RetransmissionFlowControlMode.ERTM, fcs=FcsType.NO_FCS)

        dut_channel.send(b'abc')
        dut_channel.send(b'abc')
        assertThat(cert_channel).emits(
            L2capMatchers.IFrame(tx_seq=0), L2capMatchers.IFrame(tx_seq=1),
            L2capMatchers.SFrame(p=Poll.POLL)).inOrder()

        cert_channel.send_s_frame(req_seq=0, s=SupervisoryFunction.SELECT_REJECT)
        assertThat(cert_channel).emitsNone(timeout=timedelta(seconds=0.5))

        cert_channel.send_s_frame(req_seq=0, s=SupervisoryFunction.SELECT_REJECT, f=Final.POLL_RESPONSE)
        assertThat(cert_channel).emits(L2capMatchers.IFrame(tx_seq=0))

    @metadata(
        pts_test_id="L2CAP/ERM/BI-04-C",
        pts_test_name="Handle Receipt of S-Frame [REJ] and S-Frame "
        "[RR, F=1] that Both Require Retransmission of the "
        "Same I-Frames")
    def test_handle_receipt_rej_and_rr_with_f_set(self):
        """
        Verify the IUT will only retransmit the requested I-frames once after
        receiving an S-frame [REJ] followed by an S-frame [RR] with the Final
        bit set that indicates the same I-frames should be retransmitted
        """
        self._setup_link_from_cert()

        (dut_channel, cert_channel) = self._open_channel_from_cert(
            mode=RetransmissionFlowControlMode.ERTM, fcs=FcsType.NO_FCS)

        dut_channel.send(b'abc')
        dut_channel.send(b'abc')
        assertThat(cert_channel).emits(
            L2capMatchers.IFrame(tx_seq=0),
            L2capMatchers.IFrame(tx_seq=1),
            L2capMatchers.SFrame(p=l2cap_packets.Poll.POLL)).inOrder()

        cert_channel.send_s_frame(req_seq=0, s=SupervisoryFunction.REJECT)
        assertThat(cert_channel).emitsNone(timeout=timedelta(seconds=0.5))

        # Send RR with F set
        cert_channel.send_s_frame(req_seq=0, s=SupervisoryFunction.REJECT, f=Final.POLL_RESPONSE)
        assertThat(cert_channel).emits(L2capMatchers.IFrame(tx_seq=0))
        assertThat(cert_channel).emits(L2capMatchers.IFrame(tx_seq=1))

    @metadata(
        pts_test_id="L2CAP/ERM/BI-05-C",
        pts_test_name="Handle receipt of S-Frame [REJ] and I-Frame [F=1] "
        "that Both Require Retransmission of the Same "
        "I-Frames")
    def test_handle_rej_and_i_frame_with_f_set(self):
        """
        Verify the IUT will only retransmit the requested I-frames once after
        receiving an S-frame [REJ] followed by an I-frame with the Final bit
        set that indicates the same I-frames should be retransmitted
        """
        self._setup_link_from_cert()

        (dut_channel, cert_channel) = self._open_channel_from_cert(
            mode=RetransmissionFlowControlMode.ERTM, fcs=FcsType.NO_FCS)

        dut_channel.send(b'abc')
        dut_channel.send(b'abc')
        assertThat(cert_channel).emits(
            L2capMatchers.IFrame(tx_seq=0),
            L2capMatchers.IFrame(tx_seq=1),
            L2capMatchers.SFrame(p=l2cap_packets.Poll.POLL)).inOrder()

        # Send SREJ with F not set
        cert_channel.send_s_frame(req_seq=0, s=SupervisoryFunction.SELECT_REJECT)
        assertThat(cert_channel).emitsNone(timeout=timedelta(seconds=0.5))

        cert_channel.send_i_frame(tx_seq=0, req_seq=0, f=Final.POLL_RESPONSE, payload=SAMPLE_PACKET)

        assertThat(cert_channel).emits(L2capMatchers.IFrame(tx_seq=0))
        assertThat(cert_channel).emits(L2capMatchers.IFrame(tx_seq=1))

    @metadata(
        pts_test_id="L2CAP/CMC/BV-01-C", pts_test_name="IUT Initiated Configuration of Enhanced "
        "Retransmission Mode")
    def test_initiated_configuration_request_ertm(self):
        """
        Verify the IUT can send a Configuration Request command containing the
        F&EC option that specifies Enhanced Retransmission Mode
        """
        self._setup_link_from_cert()

        self._open_unconfigured_channel_from_cert(scid=0x41, psm=0x33, mode=RetransmissionFlowControlMode.ERTM)

        assertThat(self.cert_l2cap.get_control_channel()).emits(L2capMatchers.ConfigurationRequestWithErtm())

    @metadata(
        pts_test_id="L2CAP/CMC/BV-02-C",
        pts_test_name="Lower Tester Initiated Configuration of Enhanced "
        "Retransmission Mode")
    def test_respond_configuration_request_ertm(self):
        """
        Verify the IUT can accept a Configuration Request from the Lower Tester
        containing an F&EC option that specifies Enhanced Retransmission Mode
        """
        self._setup_link_from_cert()

        self._open_channel_from_dut(psm=0x33, mode=RetransmissionFlowControlMode.ERTM)

    @metadata(
        pts_test_id="L2CAP/CMC/BV-12-C",
        pts_test_name="ERTM Not Supported by Lower Tester for Mandatory "
        "ERTM channel")
    def test_respond_not_support_ertm_when_using_mandatory_ertm(self):
        """
        The IUT is initiating connection of an L2CAP channel that mandates use
        of ERTM. Verify the IUT will not attempt to configure the connection to
        ERTM if the Lower Tester has not indicated support for ERTM in the
        Information Response [Extended Features]
        """
        self._setup_link_from_cert()
        self.cert_l2cap.claim_ertm_unsupported()
        dut_channel_future = self.dut_l2cap.connect_dynamic_channel_to_cert(
            psm=0x33, mode=RetransmissionFlowControlMode.ERTM)
        assertThat(self.cert_l2cap.get_control_channel()).emitsNone(L2capMatchers.ConnectionRequest(0x33))

    @metadata(
        pts_test_id="L2CAP/CMC/BI-01-C",
        pts_test_name="Failed Configuration of Enhanced Retransmission "
        "Mode when use of the Mode is Mandatory]")
    def test_config_respond_basic_mode_when_using_mandatory_ertm(self):
        """
        When creating a connection for a PSM that mandates the use of ERTM
        verify the IUT can handle receipt (close the channel in accordance with
        the specification) of a Configure Response indicating the peer L2CAP
        entity doesn’t wish to use Enhanced Retransmission Mode (Configure
        Response Result = Reject Unacceptable Parameters)
        """

        self._setup_link_from_cert()

        (dut_channel, cert_channel) = self._open_channel_from_cert(
            mode=RetransmissionFlowControlMode.ERTM,
            req_config_options=CertL2cap.config_option_ertm(),
            rsp_config_options=CertL2cap.config_option_basic_explicit())

        cert_channel.verify_disconnect_request()

    @metadata(
        pts_test_id="L2CAP/CMC/BI-02-C",
        pts_test_name="Configuration Mode mismatch when use of Enhanced "
        "Retransmission Mode is Mandatory")
    def test_config_request_basic_mode_when_using_mandatory_ertm(self):
        """
        When creating a connection for a PSM that mandates the use of ERTM,
        verify the IUT will close the channel if the Lower Tester attempts to
        configure Basic Mode.
        """
        self._setup_link_from_cert()

        (dut_channel, cert_channel) = self._open_unconfigured_channel_from_cert(mode=RetransmissionFlowControlMode.ERTM)
        cert_channel.send_configure_request(CertL2cap.config_option_basic_explicit())
        cert_channel.verify_disconnect_request()

    def test_initiate_connection_for_security(self):
        """
        This will test the PyL2cap API for initiating a connection for security
        via the security api
        """
        self.dut.neighbor.EnablePageScan(neighbor_facade.EnableMsg(enabled=True))
        self.cert.neighbor.EnablePageScan(neighbor_facade.EnableMsg(enabled=True))
        self.dut_l2cap.initiate_connection_for_security()
        self.cert_l2cap.accept_incoming_connection()
        self.dut_l2cap.verify_security_connection()