// Copyright 2021 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

use {
    crate::{
        channel::{Cbw, Channel},
        ie::{self, fake_ies::fake_wmm_param, write_wmm_param, IeType},
        mac,
        test_utils::fake_frames::{
            fake_eap_rsne, fake_wpa1_ie, fake_wpa2_enterprise_rsne, fake_wpa2_rsne,
            fake_wpa2_tkip_ccmp_rsne, fake_wpa2_tkip_only_rsne, fake_wpa2_wpa3_rsne,
            fake_wpa3_enterprise_192_bit_rsne, fake_wpa3_rsne, fake_wpa3_transition_rsne,
        },
    },
    anyhow::Context,
    fidl_fuchsia_wlan_common as fidl_common, fidl_fuchsia_wlan_ieee80211 as fidl_ieee80211,
    fidl_fuchsia_wlan_internal as fidl_internal, fidl_fuchsia_wlan_sme as fidl_sme,
    ieee80211::Ssid,
    num_derive::FromPrimitive,
    num_traits::FromPrimitive,
    rand::{
        distributions::{Distribution, Standard},
        Rng,
    },
};

#[rustfmt::skip]
const DEFAULT_MOCK_IES: &'static [u8] = &[
    // DS parameter set: channel 140
    0x03, 0x01, 0x8c,
    // TIM - DTIM count: 0, DTIM period: 1, PVB: 2
    0x05, 0x04, 0x00, 0x01, 0x00, 0x02,
    // Country info
    0x07, 0x10, 0x55, 0x53, 0x20, // US, Any environment
    0x24, 0x04, 0x24, // 1st channel: 36, # channels: 4, maximum tx power: 36 dBm
    0x34, 0x04, 0x1e, // 1st channel: 52, # channels: 4, maximum tx power: 30 dBm
    0x64, 0x0c, 0x1e, // 1st channel: 100, # channels: 12, maximum tx power: 30 dBm
    0x95, 0x05, 0x24, // 1st channel: 149, # channels: 5, maximum tx power: 36 dBm
    0x00, // padding
    // Power constraint: 0
    0x20, 0x01, 0x00,
    // TPC Report Transmit Power: 9, Link Margin: 0
    0x23, 0x02, 0x09, 0x00,
    // HT Capabilities
    0x2d, 0x1a, 0xef, 0x09, // HT capabilities info
    0x17, // A-MPDU parameters
    0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, // MCS set
    0x00, 0x00, // HT extended capabilities
    0x00, 0x00, 0x00, 0x00, // Transmit beamforming
    0x00, // Antenna selection capabilities
    // HT Operation
    0x3d, 0x16, 0x8c, // Primary channel: 140
    0x0d, // HT info subset - secondary channel above, any channel width, RIFS permitted
    0x16, 0x00, 0x00, 0x00, // HT info subsets
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, // Basic MCS set
    // Extended Capabilities: extended channel switching, BSS transition, operating mode notification
    0x7f, 0x08, 0x04, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x40,
    // VHT Capabilities
    0xbf, 0x0c, 0x91, 0x59, 0x82, 0x0f, // VHT capabilities info
    0xea, 0xff, 0x00, 0x00, 0xea, 0xff, 0x00, 0x00, // VHT supported MCS set
    // VHT Operation
    0xc0, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00,
    // VHT Tx Power Envelope
    0xc3, 0x03, 0x01, 0x24, 0x24,
    // Aruba, Hewlett Packard vendor-specific IE
    0xdd, 0x07, 0x00, 0x0b, 0x86, 0x01, 0x04, 0x08, 0x09,
];

pub struct BssDescriptionCreator {
    // *** Fields already in fidl_internal::BssDescription
    pub bssid: [u8; 6],
    pub bss_type: fidl_common::BssType,
    pub beacon_period: u16,
    pub channel: Channel,
    pub rssi_dbm: i8,
    pub snr_db: i8,

    // *** Custom arguments
    pub protection_cfg: FakeProtectionCfg,
    pub ssid: Ssid,
    pub rates: Vec<u8>,
    pub wmm_param: Option<ie::WmmParam>,

    // *** Modifiable capability_info bits
    // The privacy, ess, and ibss bits are reserved for the
    // macro to set since they are implied by protection_cfg
    // and bss_type.
    pub cf_pollable: bool,
    pub cf_poll_req: bool,
    pub short_preamble: bool,
    pub spectrum_mgmt: bool,
    pub qos: bool,
    pub short_slot_time: bool,
    pub apsd: bool,
    pub radio_measurement: bool,
    pub delayed_block_ack: bool,
    pub immediate_block_ack: bool,

    pub ies_overrides: IesOverrides,
}

impl BssDescriptionCreator {
    pub fn create_bss_description(self) -> Result<fidl_internal::BssDescription, anyhow::Error> {
        let mut ies_updater = ie::IesUpdater::new(DEFAULT_MOCK_IES.to_vec());
        ies_updater.set(IeType::SSID, &self.ssid[..]).context("set SSID")?;

        let rates_writer = ie::RatesWriter::try_new(&self.rates[..]).context("set rates")?;
        let mut rates_buf = vec![];
        rates_writer.write_supported_rates(&mut rates_buf);
        ies_updater.set_raw(&rates_buf[..]).context("set rates")?;

        let mut ext_rates_buf = vec![];
        rates_writer.write_extended_supported_rates(&mut ext_rates_buf);
        ies_updater.set_raw(&ext_rates_buf[..]).context("set extended rates")?;

        if let Some(rsne) = derive_rsne(self.protection_cfg) {
            ies_updater.set_raw(&rsne[..]).context("set RSNE")?;
        }
        if let Some(wpa1_vendor_ie) = derive_wpa1_vendor_ies(self.protection_cfg) {
            ies_updater.set_raw(&wpa1_vendor_ie[..]).context("set WPA1 vendor IE")?;
        }

        if let Some(wmm_param) = self.wmm_param {
            let mut wmm_param_vendor_ie = vec![];
            write_wmm_param(&mut wmm_param_vendor_ie, &wmm_param)
                .context("failed to write WmmParam to vendor IE buffer")?;
            ies_updater.set_raw(&wmm_param_vendor_ie[..]).context("set WMM parameter IE")?;
        }

        let capability_info = mac::CapabilityInfo(0)
            .with_cf_pollable(self.cf_pollable)
            .with_cf_poll_req(self.cf_poll_req)
            .with_short_preamble(self.short_preamble)
            .with_spectrum_mgmt(self.spectrum_mgmt)
            .with_qos(self.qos)
            .with_short_slot_time(self.short_slot_time)
            .with_apsd(self.apsd)
            .with_radio_measurement(self.radio_measurement)
            .with_delayed_block_ack(self.delayed_block_ack)
            .with_immediate_block_ack(self.immediate_block_ack);

        // Some values of capability_info are not permitted to be set by
        // the macro since otherwise the BssDescription will be trivially invalid.
        let capability_info = match self.protection_cfg {
            FakeProtectionCfg::Open => capability_info.with_privacy(false),
            _ => capability_info.with_privacy(true),
        };
        let capability_info = match self.bss_type {
            fidl_common::BssType::Infrastructure => capability_info.with_ess(true).with_ibss(false),
            _ => panic!("{:?} is not supported", self.bss_type),
        };
        let capability_info = capability_info.0;

        for ovr in self.ies_overrides.overrides {
            match ovr {
                IeOverride::Remove(ie_type) => ies_updater.remove(&ie_type),
                IeOverride::Set(ie_type, bytes) => {
                    ies_updater
                        .set(ie_type, &bytes[..])
                        .with_context(|| format!("set IE type: {:?}", ie_type))?;
                }
                IeOverride::SetRaw(bytes) => {
                    ies_updater.set_raw(&bytes[..]).context("set raw IE")?;
                }
            }
        }

        Ok(fidl_internal::BssDescription {
            bssid: self.bssid,
            bss_type: self.bss_type,
            beacon_period: self.beacon_period,
            capability_info,
            ies: ies_updater.finalize(),
            channel: self.channel.into(),
            rssi_dbm: self.rssi_dbm,
            snr_db: self.snr_db,
        })
    }
}

pub struct IesOverrides {
    overrides: Vec<IeOverride>,
}

impl IesOverrides {
    pub fn new() -> Self {
        Self { overrides: vec![] }
    }

    pub fn remove(mut self, ie_type: IeType) -> Self {
        self.overrides.push(IeOverride::Remove(ie_type));
        self
    }

    pub fn set(mut self, ie_type: IeType, bytes: Vec<u8>) -> Self {
        self.overrides.push(IeOverride::Set(ie_type, bytes));
        self
    }

    pub fn set_raw(mut self, bytes: Vec<u8>) -> Self {
        self.overrides.push(IeOverride::SetRaw(bytes));
        self
    }
}

enum IeOverride {
    Remove(IeType),
    Set(IeType, Vec<u8>),
    SetRaw(Vec<u8>),
}

const LAST_FAKE_PROTECTION_CFG_VALUE: isize = 14;

#[derive(Debug, FromPrimitive, Copy, Clone, PartialEq)]
pub enum FakeProtectionCfg {
    Open = 0,
    Wep,
    Wpa1,
    Wpa1Enhanced,
    Wpa1Wpa2TkipOnly,
    Wpa2TkipOnly,
    Wpa1Wpa2,
    Wpa2TkipCcmp,
    Wpa2Enterprise,
    Wpa2,
    Wpa2Wpa3,
    Wpa3Transition,
    Wpa3,
    Wpa3Enterprise,
    Eap = LAST_FAKE_PROTECTION_CFG_VALUE,
}

impl Distribution<FakeProtectionCfg> for Standard {
    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> FakeProtectionCfg {
        let r = rng.gen_range(0..LAST_FAKE_PROTECTION_CFG_VALUE + 1);
        FromPrimitive::from_isize(r)
            .unwrap_or_else(|| panic!("Out of range random value for FakeProtectionCfg: {:?}", r))
    }
}

impl From<fidl_sme::Protection> for FakeProtectionCfg {
    fn from(protection: fidl_sme::Protection) -> Self {
        match protection {
            fidl_sme::Protection::Unknown => panic!("unknown protection"),
            fidl_sme::Protection::Open => FakeProtectionCfg::Open,
            fidl_sme::Protection::Wep => FakeProtectionCfg::Wep,
            fidl_sme::Protection::Wpa1 => FakeProtectionCfg::Wpa1,
            fidl_sme::Protection::Wpa1Wpa2PersonalTkipOnly => FakeProtectionCfg::Wpa1Wpa2TkipOnly,
            fidl_sme::Protection::Wpa2PersonalTkipOnly => FakeProtectionCfg::Wpa2TkipOnly,
            fidl_sme::Protection::Wpa1Wpa2Personal => FakeProtectionCfg::Wpa1Wpa2,
            fidl_sme::Protection::Wpa2Personal => FakeProtectionCfg::Wpa2,
            fidl_sme::Protection::Wpa2Wpa3Personal => FakeProtectionCfg::Wpa2Wpa3,
            fidl_sme::Protection::Wpa3Personal => FakeProtectionCfg::Wpa3,
            fidl_sme::Protection::Wpa2Enterprise => FakeProtectionCfg::Wpa2Enterprise,
            fidl_sme::Protection::Wpa3Enterprise => FakeProtectionCfg::Wpa3Enterprise,
        }
    }
}

pub fn build_fake_bss_description_creator__(
    protection_cfg: FakeProtectionCfg,
) -> BssDescriptionCreator {
    BssDescriptionCreator {
        bssid: [0x07, 0x01, 0x02, 0x4d, 0x35, 0x08],
        bss_type: fidl_common::BssType::Infrastructure,
        beacon_period: 100,
        channel: Channel::new(3, Cbw::Cbw40),
        rssi_dbm: 0,
        snr_db: 0,

        protection_cfg,
        ssid: Ssid::try_from("fake-ssid").unwrap(),
        rates: vec![0x82, 0x84, 0x8b, 0x96, 0x0c, 0x12, 0x18, 0x24, 0x30, 0x48, 0x60, 0x6c],
        wmm_param: Some(fake_wmm_param()),

        cf_pollable: false,
        cf_poll_req: false,
        short_preamble: false,
        spectrum_mgmt: false,
        qos: false,
        short_slot_time: false,
        apsd: false,
        radio_measurement: false,
        delayed_block_ack: false,
        immediate_block_ack: false,

        ies_overrides: IesOverrides::new(),
    }
}

fn random_ecw_min_max(rng: &mut rand::prelude::ThreadRng) -> ie::EcwMinMax {
    let min = rng.gen_range(0x0..0xf);
    let max = rng.gen_range(min..0xf);
    ie::EcwMinMax((max << 4) | min)
}

pub fn build_random_bss_description_creator__(
    protection_cfg: FakeProtectionCfg,
) -> BssDescriptionCreator {
    // Only the Infrastructure BSS type is supported.
    let bss_type = fidl_common::BssType::Infrastructure;

    let mut rng = rand::thread_rng();

    // Random rates
    let mut rates: Vec<u8> = vec![];
    for _ in 0..rng.gen_range(1..ie::SUPPORTED_RATES_MAX_LEN + ie::EXTENDED_SUPPORTED_RATES_MAX_LEN)
    {
        rates.push(rng.gen());
    }
    let rates = rates; // shadow to make rates immutable

    // Random IE bytes
    let mut giant_vendor_ies = vec![];
    for _j in 0..8 {
        giant_vendor_ies.extend_from_slice(&[221, 250]);
        giant_vendor_ies.extend((0..250).map(|_| rng.gen::<u8>()))
    }
    let ies_overrides = IesOverrides::new().set_raw(giant_vendor_ies);

    let qos: bool = rng.gen();
    let apsd: bool = qos && rng.gen(); // APSD is a QoS capability, so the AP must also be QoS capable

    BssDescriptionCreator {
        bssid: (0..6).map(|_| rng.gen::<u8>()).collect::<Vec<u8>>().try_into().unwrap(),
        bss_type,
        beacon_period: rng.gen::<u16>(),
        // TODO(https://fxbug.dev/42162492): Purely random valid channel values is not implemented.
        channel: Channel::new(rng.gen_range(1..255), Cbw::Cbw20),
        rssi_dbm: rng.gen::<i8>(),
        snr_db: rng.gen::<i8>(),

        protection_cfg,
        ssid: Ssid::from_bytes_unchecked(
            (0..fidl_ieee80211::MAX_SSID_BYTE_LEN).map(|_| rng.gen::<u8>()).collect::<Vec<u8>>(),
        ),
        rates,

        // WMM is independent of 802.11 QoS, so the capabilities randomly indicated
        // in wmm_param are not related to the QoS and APSD bits in the Capability Information
        // field indicated. See WMM Specification, Section 1.3.
        wmm_param: if rng.gen() {
            Some(ie::WmmParam {
                wmm_info: ie::WmmInfo(0).with_ap_wmm_info(
                    ie::ApWmmInfo(0)
                        .with_parameter_set_count(rng.gen_range(0x00..0xf))
                        .with_uapsd(rng.gen()),
                ),
                _reserved: rng.gen(),
                ac_be_params: ie::WmmAcParams {
                    aci_aifsn: ie::WmmAciAifsn(0).with_aifsn(rng.gen_range(2..0xf)).with_aci(0),
                    ecw_min_max: random_ecw_min_max(&mut rng),
                    txop_limit: rng.gen(),
                },
                ac_bk_params: ie::WmmAcParams {
                    aci_aifsn: ie::WmmAciAifsn(0).with_aifsn(rng.gen_range(2..0xf)).with_aci(1),
                    ecw_min_max: random_ecw_min_max(&mut rng),
                    txop_limit: rng.gen(),
                },
                ac_vi_params: ie::WmmAcParams {
                    aci_aifsn: ie::WmmAciAifsn(0).with_aifsn(rng.gen_range(2..0xf)).with_aci(2),
                    ecw_min_max: random_ecw_min_max(&mut rng),
                    txop_limit: rng.gen(),
                },
                ac_vo_params: ie::WmmAcParams {
                    aci_aifsn: ie::WmmAciAifsn(0).with_aifsn(rng.gen_range(2..0xf)).with_aci(3),
                    ecw_min_max: random_ecw_min_max(&mut rng),
                    txop_limit: rng.gen(),
                },
            })
        } else {
            None
        },

        cf_pollable: rng.gen(),
        cf_poll_req: rng.gen(),
        short_preamble: rng.gen(),
        spectrum_mgmt: rng.gen(),
        qos,
        short_slot_time: rng.gen(),
        apsd,
        radio_measurement: rng.gen(),
        delayed_block_ack: rng.gen(),
        immediate_block_ack: rng.gen(),

        // Generating completely random IEs would be chaotic at best, so we
        // generate some random vendor ies instead.
        ies_overrides,
    }
}

fn derive_rsne(protection_cfg: FakeProtectionCfg) -> Option<Vec<u8>> {
    match protection_cfg {
        FakeProtectionCfg::Wpa3Enterprise => Some(fake_wpa3_enterprise_192_bit_rsne()),
        FakeProtectionCfg::Wpa2Enterprise => Some(fake_wpa2_enterprise_rsne()),
        FakeProtectionCfg::Wpa3 => Some(fake_wpa3_rsne()),
        FakeProtectionCfg::Wpa3Transition => Some(fake_wpa3_transition_rsne()),
        FakeProtectionCfg::Wpa2Wpa3 => Some(fake_wpa2_wpa3_rsne()),
        FakeProtectionCfg::Wpa2TkipCcmp => Some(fake_wpa2_tkip_ccmp_rsne()),
        FakeProtectionCfg::Wpa1Wpa2TkipOnly | FakeProtectionCfg::Wpa2TkipOnly => {
            Some(fake_wpa2_tkip_only_rsne())
        }
        FakeProtectionCfg::Wpa1Wpa2 | FakeProtectionCfg::Wpa2 => Some(fake_wpa2_rsne()),
        FakeProtectionCfg::Eap => Some(fake_eap_rsne()),
        _ => None,
    }
}

fn derive_wpa1_vendor_ies(protection_cfg: FakeProtectionCfg) -> Option<Vec<u8>> {
    match protection_cfg {
        FakeProtectionCfg::Wpa1
        | FakeProtectionCfg::Wpa1Wpa2TkipOnly
        | FakeProtectionCfg::Wpa1Wpa2 => Some(fake_wpa1_ie(false)),
        FakeProtectionCfg::Wpa1Enhanced => Some(fake_wpa1_ie(true)),
        _ => None,
    }
}

#[macro_export]
macro_rules! fake_fidl_bss_description__ {
    ($build_fake_bss_description_creator__:path, $fake_protection_cfg:expr $(, $bss_key:ident: $bss_value:expr)*) => {{
        #[allow(unknown_lints, clippy::unnecessary_struct_initialization)]
        let bss_description_creator = $crate::test_utils::fake_stas::BssDescriptionCreator {
            $(
                $bss_key: $bss_value,
            )*
            ..$build_fake_bss_description_creator__($fake_protection_cfg.into())
        };
        bss_description_creator.create_bss_description().expect("expect creating BSS to succeed")
    }};
}

#[macro_export]
macro_rules! fake_fidl_bss_description {
    ($protection_name:ident $(, $bss_key:ident: $bss_value:expr)* $(,)?) => {{
        $crate::fake_fidl_bss_description__!(
            $crate::test_utils::fake_stas::build_fake_bss_description_creator__,
            $crate::test_utils::fake_stas::FakeProtectionCfg::$protection_name
                $(, $bss_key: $bss_value)*)
    }};
    (protection => $fake_protection_cfg:expr $(, $bss_key:ident: $bss_value:expr)* $(,)?) => {{
        $crate::fake_fidl_bss_description__!(
            $crate::test_utils::fake_stas::build_fake_bss_description_creator__,
            $fake_protection_cfg
                $(, $bss_key: $bss_value)*)
    }};
}

#[macro_export]
macro_rules! random_fidl_bss_description {
    ($($bss_key:ident: $bss_value:expr),* $(,)?) => {{
        let mut rng = rand::thread_rng();
        $crate::fake_fidl_bss_description__!(
            $crate::test_utils::fake_stas::build_random_bss_description_creator__,
            rng.gen::<$crate::test_utils::fake_stas::FakeProtectionCfg>()
                $(, $bss_key: $bss_value)*)
    }};
    ($protection_name:ident $(, $bss_key:ident: $bss_value:expr)* $(,)?) => {{
        $crate::fake_fidl_bss_description__!(
            $crate::test_utils::fake_stas::build_random_bss_description_creator__,
            $crate::test_utils::fake_stas::FakeProtectionCfg::$protection_name
                $(, $bss_key: $bss_value)*)
    }};
    (protection => $fake_protection_cfg:expr $(, $bss_key:ident: $bss_value:expr)* $(,)?) => {{
        $crate::fake_fidl_bss_description__!(
            $crate::test_utils::fake_stas::build_random_bss_description_creator__,
            $fake_protection_cfg
                $(, $bss_key: $bss_value)*)
    }};
}

#[macro_export]
macro_rules! fake_bss_description__ {
    ($fidl_bss_description_macro:ident, $fake_protection_cfg:expr $(, $bss_key:ident: $bss_value:expr)* $(,)?) => {{
        let fidl_bss = $crate::$fidl_bss_description_macro!(protection => $fake_protection_cfg $(, $bss_key: $bss_value)*);
        let bss_description: $crate::bss::BssDescription = std::convert::TryFrom::try_from(fidl_bss)
            .expect("expect BSS conversion to succeed");
        bss_description
    }}
}

#[macro_export]
macro_rules! fake_bss_description {
    ($protection_name:ident $(, $bss_key:ident: $bss_value:expr)* $(,)?) => {{
        $crate::fake_bss_description__!(
            fake_fidl_bss_description,
            $crate::test_utils::fake_stas::FakeProtectionCfg::$protection_name $(, $bss_key: $bss_value)*)
    }};
    (protection => $fake_protection_cfg:expr $(, $bss_key:ident: $bss_value:expr)* $(,)?) => {{
        $crate::fake_bss_description__!(
            fake_fidl_bss_description,
            $fake_protection_cfg $(, $bss_key: $bss_value)*)
    }};
}

#[macro_export]
macro_rules! random_bss_description {
    ($($bss_key:ident: $bss_value:expr),* $(,)?) => {{
        let mut rng = rand::thread_rng();
        $crate::fake_bss_description__!(
            random_fidl_bss_description,
            rng.gen::<$crate::test_utils::fake_stas::FakeProtectionCfg>()
                $(, $bss_key: $bss_value)*)
    }};
    ($protection_name:ident $(, $bss_key:ident: $bss_value:expr)* $(,)?) => {{
        $crate::fake_bss_description__!(
            random_fidl_bss_description,
            $crate::test_utils::fake_stas::FakeProtectionCfg::$protection_name $(, $bss_key: $bss_value)*)
    }};
    (protection => $fake_protection_cfg:expr $(, $bss_key:ident: $bss_value:expr)* $(,)?) => {{
        $crate::fake_bss_description__!(
            random_fidl_bss_description,
            $fake_protection_cfg $(, $bss_key: $bss_value)*)
    }};
}

#[cfg(test)]
mod tests {
    use {
        super::*,
        crate::{
            bss::{BssDescription, Protection},
            test_utils::fake_frames::{fake_wmm_param_body, fake_wmm_param_header},
        },
    };

    #[test]
    fn check_simplest_macro_use() {
        let fidl_bss_description = fake_fidl_bss_description!(Open);
        let bss_description = fake_bss_description!(Open);
        assert_eq!(
            BssDescription::try_from(fidl_bss_description)
                .expect("Failed to convert fake_fidl_bss_description value"),
            bss_description
        );

        for i in 1..=11 {
            if i > 10 {
                panic!("random_bss_description is always equal to bss_description");
            }

            let random_fidl_bss_description = random_fidl_bss_description!(Open);
            let random_bss_description =
                BssDescription::try_from(random_fidl_bss_description.clone())
                    .expect("Failed to convert random_fidl_bss_description value");
            if random_bss_description != bss_description {
                break;
            }
        }

        for i in 1..=11 {
            if i > 10 {
                panic!("random_bss_description is always equal to other_random_bss_description");
            }

            let random_fidl_bss_description = random_fidl_bss_description!(Open);
            let random_bss_description =
                BssDescription::try_from(random_fidl_bss_description.clone())
                    .expect("Failed to convert random_fidl_bss_description value");
            let other_random_bss_description = random_bss_description!(Open);
            if random_bss_description != other_random_bss_description {
                break;
            }
        }
    }

    #[test]
    fn fake_protection_cfg_from_primitive() {
        assert!(
            0 <= LAST_FAKE_PROTECTION_CFG_VALUE,
            "LAST_FAKE_PROTECTION_CFG_VALUE is not positive: {}",
            LAST_FAKE_PROTECTION_CFG_VALUE,
        );

        let too_low: Option<FakeProtectionCfg> = FromPrimitive::from_isize(-1);
        assert_eq!(
            too_low, None::<FakeProtectionCfg>,
            "Successfully converted low out of range FakeProtectionCfg value"
        );

        for i in 0..(LAST_FAKE_PROTECTION_CFG_VALUE + 1) {
            let _: FakeProtectionCfg = FromPrimitive::from_isize(i).unwrap_or_else(|| {
                panic!("Failed to convert {:?} to a FakeProtectionCfg value", i)
            });
        }

        let too_high: Option<FakeProtectionCfg> =
            FromPrimitive::from_isize(LAST_FAKE_PROTECTION_CFG_VALUE + 1);
        assert_eq!(
            too_high, None::<FakeProtectionCfg>,
            "Successfully converted high out of range FakeProtectionCfg value"
        );
    }

    #[test]
    fn fake_protection_cfg_expr_syntax() {
        let fidl_bss_description =
            fake_fidl_bss_description!(protection => FakeProtectionCfg::Open);
        assert_eq!(
            BssDescription::try_from(fidl_bss_description)
                .expect("Failed to convert fake_fidl_bss_description value")
                .protection(),
            Protection::Open
        );

        let fidl_bss_description =
            random_fidl_bss_description!(protection => FakeProtectionCfg::Open);
        assert_eq!(
            BssDescription::try_from(fidl_bss_description)
                .expect("Failed to convert random_fidl_bss_description value")
                .protection(),
            Protection::Open
        );

        let bss_description = fake_bss_description!(protection => FakeProtectionCfg::Open);
        assert_eq!(bss_description.protection(), Protection::Open);

        let bss_description = random_bss_description!(protection => FakeProtectionCfg::Open);
        assert_eq!(bss_description.protection(), Protection::Open);
    }

    #[test]
    fn fake_protection_cfg_privacy_bit_and_protection() {
        let bss = fake_bss_description!(Open);
        assert!(!mac::CapabilityInfo(bss.capability_info).privacy());
        assert_eq!(bss.protection(), Protection::Open);

        let bss = fake_bss_description!(Wep);
        assert!(mac::CapabilityInfo(bss.capability_info).privacy());
        assert_eq!(bss.protection(), Protection::Wep);

        let bss = fake_bss_description!(Wpa1);
        assert!(mac::CapabilityInfo(bss.capability_info).privacy());
        assert_eq!(bss.protection(), Protection::Wpa1);

        let bss = fake_bss_description!(Wpa2);
        assert!(mac::CapabilityInfo(bss.capability_info).privacy());
        assert_eq!(bss.protection(), Protection::Wpa2Personal);
    }

    #[test]
    fn fake_protection_cfg_privacy_bit_and_protection_in_random_bss() {
        let bss = random_bss_description!(Open);
        assert!(!mac::CapabilityInfo(bss.capability_info).privacy());
        assert_eq!(bss.protection(), Protection::Open);

        let bss = random_bss_description!(Wep);
        assert!(mac::CapabilityInfo(bss.capability_info).privacy());
        assert_eq!(bss.protection(), Protection::Wep);

        let bss = random_bss_description!(Wpa1);
        assert!(mac::CapabilityInfo(bss.capability_info).privacy());
        assert_eq!(bss.protection(), Protection::Wpa1);

        let bss = random_bss_description!(Wpa2);
        assert!(mac::CapabilityInfo(bss.capability_info).privacy());
        assert_eq!(bss.protection(), Protection::Wpa2Personal);
    }

    #[test]
    fn set_capability_info_bits() {
        macro_rules! check_bit {
            ($bit_name:ident) => {{
                let bss = fake_bss_description!(Open, $bit_name: true);
                assert!(mac::CapabilityInfo(bss.capability_info).$bit_name());
                let bss = fake_bss_description!(Open, $bit_name: false);
                assert!(!mac::CapabilityInfo(bss.capability_info).$bit_name());
            }}
        }
        check_bit!(cf_pollable);
        check_bit!(cf_poll_req);
        check_bit!(short_preamble);
        check_bit!(spectrum_mgmt);
        check_bit!(qos);
        check_bit!(short_slot_time);
        check_bit!(apsd);
        check_bit!(radio_measurement);
        check_bit!(delayed_block_ack);
        check_bit!(immediate_block_ack);

        let bss =
            fake_bss_description!(Open, cf_pollable: true, apsd: false, immediate_block_ack: true);
        assert!(mac::CapabilityInfo(bss.capability_info).cf_pollable());
        assert!(!mac::CapabilityInfo(bss.capability_info).apsd());
        assert!(mac::CapabilityInfo(bss.capability_info).immediate_block_ack());
    }

    #[test]
    fn simple_default_override() {
        let bss = fake_fidl_bss_description!(Open);
        assert_eq!(bss.beacon_period, 100);

        let bss = fake_fidl_bss_description!(Open, beacon_period: 50);
        assert_eq!(bss.beacon_period, 50);
    }

    #[test]
    #[should_panic(expected = "Personal is not supported")]
    // TODO(https://fxbug.dev/42169733): LeakSanitizer flags leaks caused by panic.
    #[cfg_attr(feature = "variant_asan", ignore)]
    fn unsupported_bss_type() {
        fake_fidl_bss_description!(Open, bss_type: fidl_common::BssType::Personal);
    }

    #[test]
    fn any_protection_syntax() {
        let _ = random_fidl_bss_description!();
        let _ = random_bss_description!();
    }

    #[test]
    fn random_fidl_bss_decription_override() {
        let random_bss = random_bss_description!(ssid: Ssid::try_from("foo").unwrap());
        assert_eq!(random_bss.ssid, Ssid::try_from("foo").unwrap());
    }

    #[test]
    fn valid_random_ecw_min_max() {
        let mut rng = rand::thread_rng();
        for _ in 0..100 {
            let ecw_min_max = random_ecw_min_max(&mut rng);
            assert!(ecw_min_max.ecw_max() >= ecw_min_max.ecw_min());
        }
    }

    #[test]
    fn random_bss_is_not_constant() {
        for _ in 0..10 {
            let random_bss_1 = BssDescription::try_from(random_fidl_bss_description!())
                .expect("Failed to convert random_bss_description value");
            let random_bss_2 = BssDescription::try_from(random_fidl_bss_description!())
                .expect("Failed to convert random_bss_description value");
            if random_bss_1 != random_bss_2 {
                return;
            }
        }
        panic!("random bss is always the same");
    }

    #[test]
    fn random_bss_protection_is_not_constant() {
        for _ in 0..10 {
            let random_bss_1 = BssDescription::try_from(random_fidl_bss_description!())
                .expect("Failed to convert random_bss_description value");
            let random_bss_2 = BssDescription::try_from(random_fidl_bss_description!())
                .expect("Failed to convert random_bss_description value");
            if random_bss_1.protection() != random_bss_2.protection() {
                return;
            }
        }
        panic!("random bss protection is always the same");
    }

    #[test]
    fn some_random_bss_bits_are_fixed() {
        for _ in 0..5 {
            let random_bss = random_fidl_bss_description!(Open);
            assert_eq!(random_bss.bss_type, fidl_common::BssType::Infrastructure);
            assert!(mac::CapabilityInfo(random_bss.capability_info).ess());
            assert!(!mac::CapabilityInfo(random_bss.capability_info).ibss());
            assert!(!mac::CapabilityInfo(random_bss.capability_info).privacy());
        }
    }

    // Test random_bss_description generation of random protection since
    // it doesn't rely on random_fidl_bss_description for it.
    #[test]
    fn random_bss_decription_protection_randomness() {
        for _ in 0..10 {
            let random_bss_1 = random_bss_description!();
            let random_bss_2 = random_bss_description!();
            if random_bss_1.protection() != random_bss_2.protection() {
                return;
            }
        }
        panic!("random protection is always the same");
    }

    #[test]
    fn ies_overrides() {
        let bss = fake_bss_description!(Wpa1Wpa2,
            ssid: Ssid::try_from("fuchsia").unwrap(),
            rates: vec![11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24],
            ies_overrides: IesOverrides::new()
                .remove(IeType::new_vendor([0x00, 0x0b, 0x86, 0x01, 0x04, 0x08]))
                .set(IeType::DSSS_PARAM_SET, [136].to_vec()),
        );

        // Things to note:
        // - SSID "fuchsia" is inserted.
        // - Rates and extended supported rates are inserted.
        // - WPA2 RSNE and WPA1 vendor IE are inserted.
        // - DSSS Param set's value is changed.
        // - Aruba vendor IE no longer there.
        #[rustfmt::skip]
        let mut expected_ies = vec![
            // SSID
            0x00, 0x07, b'f', b'u', b'c', b'h', b's', b'i', b'a',
            // Rates
            0x01, 0x08, 11, 12, 13, 14, 15, 16, 17, 18,
            // DS parameter set: channel 136
            0x03, 0x01, 136,
            // TIM - DTIM count: 0, DTIM period: 1, PVB: 2
            0x05, 0x04, 0x00, 0x01, 0x00, 0x02,
            // Country info
            0x07, 0x10, 0x55, 0x53, 0x20, // US, Any environment
            0x24, 0x04, 0x24, // 1st channel: 36, # channels: 4, maximum tx power: 36 dBm
            0x34, 0x04, 0x1e, // 1st channel: 52, # channels: 4, maximum tx power: 30 dBm
            0x64, 0x0c, 0x1e, // 1st channel: 100, # channels: 12, maximum tx power: 30 dBm
            0x95, 0x05, 0x24, // 1st channel: 149, # channels: 5, maximum tx power: 36 dBm
            0x00, // padding
            // Power constraint: 0
            0x20, 0x01, 0x00,
            // TPC Report Transmit Power: 9, Link Margin: 0
            0x23, 0x02, 0x09, 0x00,
            // HT Capabilities
            0x2d, 0x1a, 0xef, 0x09, // HT capabilities info
            0x17, // A-MPDU parameters
            0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
            0x00, 0x00, // MCS set
            0x00, 0x00, // HT extended capabilities
            0x00, 0x00, 0x00, 0x00, // Transmit beamforming
            0x00, // Antenna selection capabilities
            // RSNE
            0x30, 18, // Element header
            1, 0, // Version
            0x00, 0x0F, 0xAC, 4, // Group Cipher: CCMP-128
            1, 0, 0x00, 0x0F, 0xAC, 4, // 1 Pairwise Cipher: CCMP-128
            1, 0, 0x00, 0x0F, 0xAC, 2, // 1 AKM: PSK
            // Extended supported rates
            0x32, 0x06, 19, 20, 21, 22, 23, 24,
            // HT Operation
            0x3d, 0x16, 0x8c, // Primary channel: 140
            0x0d, // HT info subset - secondary channel above, any channel width, RIFS permitted
            0x16, 0x00, 0x00, 0x00, // HT info subsets
            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
            0x00, 0x00, // Basic MCS set
            // Extended Capabilities: extended channel switching, BSS transition, operating mode notification
            0x7f, 0x08, 0x04, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x40,
            // VHT Capabilities
            0xbf, 0x0c, 0x91, 0x59, 0x82, 0x0f, // VHT capabilities info
            0xea, 0xff, 0x00, 0x00, 0xea, 0xff, 0x00, 0x00, // VHT supported MCS set
            // VHT Operation
            0xc0, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, // VHT Tx Power Envelope
            0xc3, 0x03, 0x01, 0x24, 0x24,
            // WPA1 vendor IE
            0xdd, 0x16, 0x00, 0x50, 0xf2, // IE header
            0x01, // MSFT specific IE type (WPA)
            0x01, 0x00, // WPA version
            0x00, 0x50, 0xf2, 0x02, // multicast cipher: TKIP
            0x01, 0x00, 0x00, 0x50, 0xf2, 0x02, // 1 unicast cipher
            0x01, 0x00, 0x00, 0x50, 0xf2, 0x02, // 1 AKM: PSK
        ];
        expected_ies.extend(fake_wmm_param_header());
        expected_ies.extend(fake_wmm_param_body());

        assert_eq!(bss.ies(), &expected_ies[..]);
    }
}