#!/usr/bin/python
#
# Copyright (c) 2013 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

import unittest

import common

from autotest_lib.client.common_lib.cros.network import iw_runner

class IwRunnerTest(unittest.TestCase):
    """Unit test for the IWRunner object."""


    class host_cmd(object):
        """Mock host command class."""

        def __init__(self, stdout, stderr, exit_status):
            self._stdout = stdout
            self._stderr = stderr
            self._exit_status = exit_status


        @property
        def stdout(self):
            """Returns stdout."""
            return self._stdout


        @property
        def stderr(self):
            """Returns stderr."""
            return self._stderr


        @property
        def exit_status(self):
            """Returns the exit status."""
            return self._exit_status


    class host(object):
        """Mock host class."""

        def __init__(self, host_cmd):
            self._host_cmd = IwRunnerTest.host_cmd(host_cmd, 1.0, 0)


        def run(self, cmd, ignore_status=False):
            """Returns the mocked output.

            @param cmd: a stub input ignore
            @param ignore_status: a stub input ignore

            """
            return self._host_cmd


    HT20 = str('BSS aa:aa:aa:aa:aa:aa (on wlan0)\n'
        '    freq: 2412\n'
        '    signal: -50.00 dBm\n'
        '    SSID: support_ht20\n'
        '    HT operation:\n'
        '         * secondary channel offset: no secondary\n')

    HT20_IW_BSS = iw_runner.IwBss('aa:aa:aa:aa:aa:aa', 2412,
                                  'support_ht20', iw_runner.SECURITY_OPEN,
                                  iw_runner.HT20, -50.00)

    HT20_2 = str('BSS 11:11:11:11:11:11 (on wlan0)\n'
        '     freq: 2462\n'
        '     signal: -42.00 dBm\n'
        '     SSID: support_ht20\n'
        '     WPA:          * Version: 1\n'
        '     HT operation:\n'
        '          * secondary channel offset: below\n')

    HT20_2_IW_BSS = iw_runner.IwBss('11:11:11:11:11:11', 2462,
                                    'support_ht20', iw_runner.SECURITY_WPA,
                                    iw_runner.HT40_BELOW, -42.00)

    HT40_ABOVE = str('BSS bb:bb:bb:bb:bb:bb (on wlan0)\n'
        '    freq: 5180\n'
        '    signal: -55.00 dBm\n'
        '    SSID: support_ht40_above\n'
        '    RSN:          * Version: 1\n'
        '    HT operation:\n'
        '         * secondary channel offset: above\n')

    HT40_ABOVE_IW_BSS = iw_runner.IwBss('bb:bb:bb:bb:bb:bb', 5180,
                                        'support_ht40_above',
                                        iw_runner.SECURITY_WPA2,
                                        iw_runner.HT40_ABOVE, -55.00)

    HT40_BELOW = str('BSS cc:cc:cc:cc:cc:cc (on wlan0)\n'
        '    freq: 2462\n'
        '    signal: -44.00 dBm\n'
        '    SSID: support_ht40_below\n'
        '    RSN:          * Version: 1\n'
        '    WPA:          * Version: 1\n'
        '    HT operation:\n'
        '        * secondary channel offset: below\n')

    HT40_BELOW_IW_BSS = iw_runner.IwBss('cc:cc:cc:cc:cc:cc', 2462,
                                        'support_ht40_below',
                                        iw_runner.SECURITY_MIXED,
                                        iw_runner.HT40_BELOW, -44.00)

    NO_HT = str('BSS dd:dd:dd:dd:dd:dd (on wlan0)\n'
        '    freq: 2412\n'
        '    signal: -45.00 dBm\n'
        '    SSID: no_ht_support\n')

    NO_HT_IW_BSS = iw_runner.IwBss('dd:dd:dd:dd:dd:dd', 2412,
                                   'no_ht_support', iw_runner.SECURITY_OPEN,
                                   None, -45.00)

    HIDDEN_SSID = str('BSS ee:ee:ee:ee:ee:ee (on wlan0)\n'
        '    freq: 2462\n'
        '    signal: -70.00 dBm\n'
        '    SSID: \n'
        '    HT operation:\n'
        '         * secondary channel offset: no secondary\n')

    SCAN_TIME_OUTPUT = str('real 4.5\n'
        'user 2.1\n'
        'system 3.1\n')

    HIDDEN_SSID_IW_BSS = iw_runner.IwBss('ee:ee:ee:ee:ee:ee', 2462,
                                         None, iw_runner.SECURITY_OPEN,
                                         iw_runner.HT20, -70.00)

    STATION_LINK_INFORMATION = str(
        'Connected to 12:34:56:ab:cd:ef (on wlan0)\n'
        '      SSID: PMKSACaching_4m9p5_ch1\n'
        '      freq: 5220\n'
        '      RX: 5370 bytes (37 packets)\n'
        '      TX: 3604 bytes (15 packets)\n'
        '      signal: -59 dBm\n'
        '      tx bitrate: 13.0 MBit/s MCS 1\n'
        '\n'
        '      bss flags:      short-slot-time\n'
        '      dtim period:    5\n'
        '      beacon int:     100\n')

    STATION_LINK_BSSID = '12:34:56:ab:cd:ef'

    STATION_LINK_IFACE = 'wlan0'

    STATION_LINK_FREQ = '5220'

    STATION_LINK_PARSED = {
        'SSID': 'PMKSACaching_4m9p5_ch1',
        'freq': '5220',
        'RX': '5370 bytes (37 packets)',
        'TX': '3604 bytes (15 packets)',
        'signal': '-59 dBm',
        'tx bitrate': '13.0 MBit/s MCS 1',
        'bss flags': 'short-slot-time',
        'dtim period': '5',
        'beacon int': '100'
        }

    STATION_DUMP_INFORMATION = str(
        'Station dd:ee:ff:33:44:55 (on mesh-5000mhz)\n'
        '        inactive time:  140 ms\n'
        '        rx bytes:       2883498\n'
        '        rx packets:     31981\n'
        '        tx bytes:       1369934\n'
        '        tx packets:     6615\n'
        '        tx retries:     4\n'
        '        tx failed:      0\n'
        '        rx drop misc:   5\n'
        '        signal:         -4 dBm\n'
        '        signal avg:     -11 dBm\n'
        '        Toffset:        81715566854 us\n'
        '        tx bitrate:     866.7 MBit/s VHT-MCS 9 80MHz '
        'short GI VHT-NSS 2\n'
        '        rx bitrate:     866.7 MBit/s VHT-MCS 9 80MHz '
        'short GI VHT-NSS 2\n'
        '        mesh llid:      0\n'
        '        mesh plid:      0\n'
        '        mesh plink:     ESTAB\n'
        '        mesh local PS mode:     ACTIVE\n'
        '        mesh peer PS mode:      ACTIVE\n'
        '        mesh non-peer PS mode:  ACTIVE\n'
        '        authorized:     yes\n'
        '        authenticated:  yes\n'
        '        preamble:       long\n'
        '        WMM/WME:        yes\n'
        '        MFP:            yes\n'
        '        TDLS peer:      no\n'
        '        connected time: 8726 seconds\n'
        'Station aa:bb:cc:00:11:22 (on mesh-5000mhz)\n'
        '        inactive time:  140 ms\n'
        '        rx bytes:       2845200\n'
        '        rx packets:     31938\n'
        '        tx bytes:       1309945\n'
        '        tx packets:     6672\n'
        '        tx retries:     0\n'
        '        tx failed:      1\n'
        '        signal:         -21 dBm\n'
        '        signal avg:     -21 dBm\n'
        '        tx bitrate:     866.7 MBit/s VHT-MCS 9 80MHz '
        'short GI VHT-NSS 2\n'
        '        rx bitrate:     650.0 MBit/s VHT-MCS 7 80MHz '
        'short GI VHT-NSS 2\n'
        '        mesh llid:      0\n'
        '        mesh plid:      0\n'
        '        mesh plink:     ESTAB\n'
        '        mesh local PS mode:     ACTIVE\n'
        '        mesh peer PS mode:      ACTIVE\n'
        '        mesh non-peer PS mode:  ACTIVE\n'
        '        authorized:     yes\n'
        '        authenticated:  yes\n'
        '        preamble:       long\n'
        '        WMM/WME:        yes\n'
        '        MFP:            yes\n'
        '        TDLS peer:      no\n'
        '        connected time: 8724 seconds\n'
        'Station ff:aa:bb:aa:44:55 (on mesh-5000mhz)\n'
        '        inactive time:  304 ms\n'
        '        rx bytes:       18816\n'
        '        rx packets:     75\n'
        '        tx bytes:       5386\n'
        '        tx packets:     21\n'
        '        signal:         -29 dBm\n'
        '        tx bitrate:     65.0 MBit/s VHT-MCS 0 80MHz short GI VHT-NSS 2\n'
        '        mesh llid:      0\n'
        '        mesh plid:      0\n'
        '        mesh plink:     ESTAB\n'
        '        mesh local PS mode:     ACTIVE\n'
        '        mesh peer PS mode:      ACTIVE\n'
        '        mesh non-peer PS mode:  ACTIVE\n'
        '        authorized:     yes\n'
        '        authenticated:  yes\n'
        '        preamble:       long\n'
        '        WMM/WME:        yes\n'
        '        MFP:            yes\n'
        '        TDLS peer:      no\n'
        '        connected time: 824 seconds\n')

    STATION_DUMP_INFORMATION_PARSED = [
        {'mac': 'aa:bb:cc:00:11:22',
        'rssi_str': '-21 dBm',
        'rssi_int': -21,
        'rx_bitrate': '650.0 MBit/s VHT-MCS 7 80MHz short GI VHT-NSS 2',
        'rx_drops': 0,
        'rx_drop_rate': 0.0,
        'rx_packets': 31938,
        'tx_bitrate': '866.7 MBit/s VHT-MCS 9 80MHz short GI VHT-NSS 2',
        'tx_failures': 1,
        'tx_failure_rate': 0.00014988009592326138,
        'tx_packets': 6672,
        'tx_retries': 0,
        'tx_retry_rate': 0.0},
        {'mac': 'dd:ee:ff:33:44:55',
        'rssi_str': '-4 dBm',
        'rssi_int': -4,
        'rx_bitrate': '866.7 MBit/s VHT-MCS 9 80MHz short GI VHT-NSS 2',
        'rx_drops': 5,
        'rx_drop_rate': 0.0001563428285544542,
        'rx_packets': 31981,
        'tx_bitrate': '866.7 MBit/s VHT-MCS 9 80MHz short GI VHT-NSS 2',
        'tx_failures': 0,
        'tx_failure_rate': 0.0,
        'tx_packets': 6615,
        'tx_retries': 4,
        'tx_retry_rate': 0.0006046863189720333},
        {'mac': 'ff:aa:bb:aa:44:55',
        'rssi_str': '-29 dBm',
        'rssi_int': -29,
        'rx_bitrate': '0',
        'rx_drops': 0,
        'rx_drop_rate': 0.0,
        'rx_packets': 75,
        'tx_bitrate': '65.0 MBit/s VHT-MCS 0 80MHz short GI VHT-NSS 2',
        'tx_failures': 0,
        'tx_failure_rate': 0.0,
        'tx_retries': 0,
        'tx_retry_rate': 0.0,
        'tx_packets': 21},
        ]

    STATION_DUMP_IFACE = 'mesh-5000mhz'

    INFO_MESH_MODE = str(
        'Interface wlan-2400mhz\n'
        '        ifindex 10\n'
        '        wdev 0x100000002\n'
        '        addr aa:bb:cc:dd:ee:ff\n'
        '        type mesh point\n'
        '        wiphy 1\n'
        '        channel 149 (5745 MHz), width: 80 MHz, center1: 5775 MHz\n')

    INFO_AP_MODE = str(
        'Interface wlan-2400mhz\n'
        '        ifindex 8\n'
        '        wdev 0x1\n'
        '        addr 00:11:22:33:44:55\n'
        '        ssid testap_170501151530_wsvx\n'
        '        type AP\n'
        '        wiphy 0\n'
        '        channel 11 (2462 MHz), width: 20 MHz, center1: 2462 MHz\n')

    RADIO_CONFIG_AP_MODE = {'number': 11, 'freq': 2462, 'width': 20,
                            'center1_freq': 2462}

    INFO_STA_MODE = str(
        'Interface wlan-2400mhz\n'
        '        ifindex 9\n'
        '        wdev 0x1\n'
        '        addr 44:55:66:77:88:99\n'
        '        type managed\n'
        '        wiphy 0\n'
        '        channel 11 (2462 MHz), width: 20 MHz, center1: 2462 MHz\n')

    INFO_IFACE = 'wlan-2400mhz'

    PHY_INFO_FRAGMENTATION = str(
        'Wiphy phy1\n'
        '        max # scan SSIDs: 20\n'
        '        max scan IEs length: 425 bytes\n'
        '        Fragmentation threshold: 256\n'
        '        Retry short limit: 7\n'
        '        Retry long limit: 4\n')

    INFO_PHY = 'phy1'

    PHY_FRAGMENTATION_THRESHOLD = 256


    def verify_values(self, iw_bss_1, iw_bss_2):
        """Checks all of the IWBss values

        @param iw_bss_1: an IWBss object
        @param iw_bss_2: an IWBss object

        """
        self.assertEquals(iw_bss_1.bss, iw_bss_2.bss)
        self.assertEquals(iw_bss_1.ssid, iw_bss_2.ssid)
        self.assertEquals(iw_bss_1.frequency, iw_bss_2.frequency)
        self.assertEquals(iw_bss_1.security, iw_bss_2.security)
        self.assertEquals(iw_bss_1.ht, iw_bss_2.ht)
        self.assertEquals(iw_bss_1.signal, iw_bss_2.signal)


    def search_by_bss(self, scan_output, test_iw_bss):
        """

        @param scan_output: the output of the scan as a string
        @param test_iw_bss: an IWBss object

        Uses the runner to search for a network by bss.
        """
        host = self.host(scan_output + self.SCAN_TIME_OUTPUT)
        runner = iw_runner.IwRunner(remote_host=host)
        network = runner.wait_for_scan_result('wlan0', bsses=[test_iw_bss.bss])
        self.verify_values(test_iw_bss, network[0])


    def test_find_first(self):
        """Test with the first item in the list."""
        scan_output = self.HT20 + self.HT40_ABOVE
        self.search_by_bss(scan_output, self.HT20_IW_BSS)


    def test_find_last(self):
        """Test with the last item in the list."""
        scan_output = self.HT40_ABOVE + self.HT20
        self.search_by_bss(scan_output, self.HT20_IW_BSS)


    def test_find_middle(self):
        """Test with the middle item in the list."""
        scan_output = self.HT40_ABOVE + self.HT20 + self.NO_HT
        self.search_by_bss(scan_output, self.HT20_IW_BSS)


    def test_ht40_above(self):
        """Test with a HT40+ network."""
        scan_output = self.HT20 + self.HT40_ABOVE + self.NO_HT
        self.search_by_bss(scan_output, self.HT40_ABOVE_IW_BSS)


    def test_ht40_below(self):
        """Test with a HT40- network."""
        scan_output = self.HT20 + self.HT40_BELOW + self.NO_HT
        self.search_by_bss(scan_output, self.HT40_BELOW_IW_BSS)


    def test_no_ht(self):
        """Test with a network that doesn't have ht."""
        scan_output = self.HT20 + self.NO_HT + self.HT40_ABOVE
        self.search_by_bss(scan_output, self.NO_HT_IW_BSS)


    def test_hidden_ssid(self):
        """Test with a network with a hidden ssid."""
        scan_output = self.HT20 + self.HIDDEN_SSID + self.NO_HT
        self.search_by_bss(scan_output, self.HIDDEN_SSID_IW_BSS)


    def test_multiple_ssids(self):
        """Test with multiple networks with the same ssids."""
        scan_output = self.HT40_ABOVE + self.HT20 + self.NO_HT + self.HT20_2
        host = self.host(scan_output + self.SCAN_TIME_OUTPUT)
        runner = iw_runner.IwRunner(remote_host=host)
        networks = runner.wait_for_scan_result('wlan 0',
                                               ssids=[self.HT20_2_IW_BSS.ssid])
        for iw_bss_1, iw_bss_2 in zip([self.HT20_IW_BSS, self.HT20_2_IW_BSS],
                                      networks):
            self.verify_values(iw_bss_1, iw_bss_2)


    def test_station_bssid(self):
        """Test parsing of the bssid of a station-mode link."""
        host = self.host(self.STATION_LINK_INFORMATION)
        runner = iw_runner.IwRunner(remote_host=host)
        self.assertEquals(
            runner.get_current_bssid(self.STATION_LINK_IFACE),
            self.STATION_LINK_BSSID)


    def test_station_link_parsing(self):
        """Test all link keys can be parsed from station link information."""
        self.assertEquals(
            iw_runner._get_all_link_keys(self.STATION_LINK_INFORMATION),
            self.STATION_LINK_PARSED)


    def test_station_link_key(self):
        """Test a link key is extracted from station link information."""
        host = self.host(self.STATION_LINK_INFORMATION)
        runner = iw_runner.IwRunner(remote_host=host)
        self.assertEquals(
            runner.get_link_value(self.STATION_LINK_INFORMATION,
                                  iw_runner.IW_LINK_KEY_FREQUENCY),
            self.STATION_LINK_FREQ)


    def test_station_dump(self):
        """Test parsing of a station dump."""
        host = self.host(self.STATION_DUMP_INFORMATION)
        runner = iw_runner.IwRunner(remote_host=host)
        self.assertEquals(
            runner.get_station_dump(self.STATION_DUMP_IFACE),
            self.STATION_DUMP_INFORMATION_PARSED)


    def test_operating_mode_mesh(self):
        """Test mesh operating mode parsing."""
        host = self.host(self.INFO_MESH_MODE)
        runner = iw_runner.IwRunner(remote_host=host)
        self.assertEquals(
            runner.get_operating_mode(self.INFO_IFACE),
            iw_runner.DEV_MODE_MESH_POINT)


    def test_operating_mode_ap(self):
        """Test AP operating mode parsing."""
        host = self.host(self.INFO_AP_MODE)
        runner = iw_runner.IwRunner(remote_host=host)
        self.assertEquals(
            runner.get_operating_mode(self.INFO_IFACE),
            iw_runner.DEV_MODE_AP)


    def test_operating_mode_station(self):
        """Test STA operating mode parsing."""
        host = self.host(self.INFO_STA_MODE)
        runner = iw_runner.IwRunner(remote_host=host)
        self.assertEquals(
            runner.get_operating_mode(self.INFO_IFACE),
            iw_runner.DEV_MODE_STATION)


    def test_radio_information(self):
        """Test radio information parsing."""
        host = self.host(self.INFO_AP_MODE)
        runner = iw_runner.IwRunner(remote_host=host)
        self.assertEquals(
            runner.get_radio_config(self.INFO_IFACE),
            self.RADIO_CONFIG_AP_MODE)


    def test_fragmentation_threshold(self):
        """Test fragmentation threshold parsing."""
        host = self.host(self.PHY_INFO_FRAGMENTATION)
        runner = iw_runner.IwRunner(remote_host=host)
        self.assertEquals(
            runner.get_fragmentation_threshold(self.INFO_PHY),
            self.PHY_FRAGMENTATION_THRESHOLD)


if __name__ == '__main__':
    unittest.main()