#!/usr/bin/python

"""Tests for connection_manager.py."""

import logging
import os
import shutil
import subprocess  # Fake subprocess module in test/fake_python.
import tempfile
import time
import traceback

import connection_manager
import experiment_testutils
import interface_test
import iw
import status
import test_common
from wvtest import wvtest

logger = logging.getLogger(__name__)


FAKE_MOCA_NODE1_FILE = """{
  "NodeId": 1,
  "RxNBAS": 25
}
"""

FAKE_MOCA_NODE1_FILE_DISCONNECTED = """{
  "NodeId": 1,
  "RxNBAS": 0
}
"""


WIFI_SHOW_OUTPUT_MARVELL8897 = (
    subprocess.wifi.MockInterface(phynum='0', bands=['2.4', '5'],
                                  driver='cfg80211'),
)
WIFI_SHOW_OUTPUT_ATH9K_ATH10K = (
    subprocess.wifi.MockInterface(phynum='0', bands=['2.4'], driver='cfg80211'),
    subprocess.wifi.MockInterface(phynum='1', bands=['5'], driver='cfg80211'),
)
# See b/27328894.
WIFI_SHOW_OUTPUT_MARVELL8897_NO_5GHZ = (
    subprocess.wifi.MockInterface(phynum='0', bands=['2.4'], driver='cfg80211'),
)
WIFI_SHOW_OUTPUT_ATH9K_FRENZY = (
    subprocess.wifi.MockInterface(phynum='0', bands=['2.4'], driver='cfg80211'),
    subprocess.wifi.MockInterface(phynum='1', bands=['5'], driver='frenzy'),
)
WIFI_SHOW_OUTPUT_FRENZY = (
    subprocess.wifi.MockInterface(phynum='0', bands=['5'], driver='frenzy'),
)

IW_SCAN_DEFAULT_OUTPUT = """BSS 00:11:22:33:44:55(on wcli0)
  SSID: s1
BSS 66:77:88:99:aa:bb(on wcli0)
  SSID: s1
BSS 01:23:45:67:89:ab(on wcli0)
  SSID: s2
"""

IW_SCAN_HIDDEN_OUTPUT = """BSS ff:ee:dd:cc:bb:aa(on wcli0)
  Vendor specific: OUI f4:f5:e8, data: 01
  Vendor specific: OUI f4:f5:e8, data: 03 73 33
"""


@test_common.wvtest
def get_client_interfaces_test():
  """Test get_client_interfaces."""
  subprocess.reset()

  subprocess.mock('wifi', 'interfaces', *WIFI_SHOW_OUTPUT_MARVELL8897)
  wvtest.WVPASSEQ(connection_manager.get_client_interfaces(),
                  {'wcli0': {'bands': set(['2.4', '5'])}})

  subprocess.mock('wifi', 'interfaces', *WIFI_SHOW_OUTPUT_ATH9K_ATH10K)
  wvtest.WVPASSEQ(connection_manager.get_client_interfaces(), {
      'wcli0': {'bands': set(['2.4'])},
      'wcli1': {'bands': set(['5'])}
  })

  # Test Quantenna devices.

  # 2.4 GHz cfg80211 radio + 5 GHz Frenzy (e.g. Optimus Prime).
  subprocess.mock('wifi', 'interfaces', *WIFI_SHOW_OUTPUT_ATH9K_FRENZY)
  wvtest.WVPASSEQ(connection_manager.get_client_interfaces(), {
      'wcli0': {'bands': set(['2.4'])},
      'wcli1': {'frenzy': True, 'bands': set(['5'])}
  })

  # Only Frenzy (e.g. Lockdown).
  subprocess.mock('wifi', 'interfaces', *WIFI_SHOW_OUTPUT_FRENZY)
  wvtest.WVPASSEQ(connection_manager.get_client_interfaces(),
                  {'wcli0': {'frenzy': True, 'bands': set(['5'])}})


@test_common.wvtest
def WLANConfigurationParseTest():  # pylint: disable=invalid-name
  """Test WLANConfiguration parsing."""
  subprocess.reset()

  cmd = '\n'.join([
      'WIFI_PSK=abcdWIFI_PSK=qwer', 'wifi', 'set', '-P', '-b', '5',
      '--bridge=br0', '-s', 'my ssid=1', '--interface-suffix', '_suffix',
  ])
  config = connection_manager.WLANConfiguration(
      '5', interface_test.Wifi('wcli0', 20), cmd, 10)

  wvtest.WVPASSEQ('my ssid=1', config.ssid)
  wvtest.WVPASSEQ('abcdWIFI_PSK=qwer', config.passphrase)
  wvtest.WVPASSEQ('_suffix', config.interface_suffix)


class Wifi(interface_test.Wifi):

  def __init__(self, *args, **kwargs):
    super(Wifi, self).__init__(*args, **kwargs)
    self.wifi_scan_counter = 0


class FrenzyWifi(interface_test.FrenzyWifi):

  def __init__(self, *args, **kwargs):
    super(FrenzyWifi, self).__init__(*args, **kwargs)
    self.wifi_scan_counter = 0


class ConnectionManager(connection_manager.ConnectionManager):
  """ConnectionManager subclass for testing."""

  # pylint: disable=invalid-name
  Bridge = interface_test.Bridge
  Wifi = Wifi
  FrenzyWifi = FrenzyWifi

  def __init__(self, *args, **kwargs):
    self._binwifi_commands = []

    for interface_name in kwargs.pop('__test_interfaces_already_up', ['eth0']):
      subprocess.call(['ifup', interface_name])
      if interface_name.startswith('w'):
        phynum = interface_name[-1]
        for band, interface in subprocess.wifi.INTERFACE_FOR_BAND.iteritems():
          if interface.phynum == phynum:
            break
        else:
          raise ValueError('Could not find matching interface for '
                           '__test_interfaces_already_up')
        ssid = 'my ssid'
        psk = 'passphrase'
        # If band is undefined then a ValueError will be raised above.  pylint
        # isn't smart enough to figure that out.
        # pylint: disable=undefined-loop-variable
        subprocess.mock('cwmp', band, ssid=ssid, psk=psk, write_now=True)
        subprocess.mock('wifi', 'remote_ap', band=band, ssid=ssid, psk=psk,
                        bssid='00:00:00:00:00:00')

    super(ConnectionManager, self).__init__(*args, **kwargs)

  # Just looking for last_wifi_scan_time to change doesn't work because the
  # tests run too fast.
  def _wifi_scan(self, wifi):
    super(ConnectionManager, self)._wifi_scan(wifi)
    wifi.wifi_scan_counter += 1

  def _binwifi(self, *command):
    super(ConnectionManager, self)._binwifi(*command)
    self._binwifi_commands.append(command)

  # Non-overrides

  def access_point_up(self, band):
    if band not in self._wlan_configuration:
      return False

    return self._wlan_configuration[band].access_point_up

  def client_up(self, band):
    if band not in self._wlan_configuration:
      return False

    return self._wlan_configuration[band].client_up

  # # Test methods

  def set_ethernet(self, up):
    self.ifplugd_action('eth0', up)

  def set_moca(self, up):
    moca_node1_file = os.path.join(self._moca_tmp_dir,
                                   self.MOCA_NODE_FILE_PREFIX + '1')
    with open(moca_node1_file, 'w') as f:
      f.write(FAKE_MOCA_NODE1_FILE if up else
              FAKE_MOCA_NODE1_FILE_DISCONNECTED)

  def run_until_interface_update(self):
    while self._interface_update_counter == 0:
      self.run_once()
    while self._interface_update_counter != 0:
      self.run_once()

  def run_until_scan(self, band):
    logger.debug('running until scan on band %r', band)
    wifi = self.wifi_for_band(band)
    wifi_scan_counter = wifi.wifi_scan_counter
    while wifi_scan_counter == wifi.wifi_scan_counter:
      self.run_once()

  def run_until_interface_update_and_scan(self, band):
    wifi = self.wifi_for_band(band)
    wifi_scan_counter = wifi.wifi_scan_counter
    self.run_until_interface_update()
    while wifi_scan_counter == wifi.wifi_scan_counter:
      self.run_once()

  def has_status_files(self, files):
    return not set(files) - set(os.listdir(self._status_dir))


def check_tmp_hosts(expected_contents):
  wvtest.WVPASSEQ(open(connection_manager.TMP_HOSTS).read(), expected_contents)


def connection_manager_test(radio_config, wlan_configs=None, **cm_kwargs):
  """Returns a decorator that does ConnectionManager test boilerplate."""
  if wlan_configs is None:
    wlan_configs = {}

  def inner(f):
    """The actual decorator."""
    def actual_test():
      """The actual test function."""
      subprocess.reset()

      run_duration_s = .01
      interface_update_period = 5
      wifi_scan_period = 15
      wifi_scan_period_s = run_duration_s * wifi_scan_period
      associate_wait_s = 0
      dhcp_wait_s = .5
      acs_cc_wait_s = 0
      acs_start_wait_s = 0
      acs_finish_wait_s = 0.25

      subprocess.mock('wifi', 'interfaces', *radio_config)

      try:
        # No initial state.
        connection_manager.TMP_HOSTS = tempfile.mktemp()
        tmp_dir = tempfile.mkdtemp()
        config_dir = tempfile.mkdtemp()
        interfaces_dir = os.path.join(tmp_dir, 'interfaces')
        if not os.path.exists(interfaces_dir):
          os.mkdir(interfaces_dir)
        moca_tmp_dir = tempfile.mkdtemp()
        wpa_control_interface = tempfile.mkdtemp()
        subprocess.mock('wifi', 'wpa_path', wpa_control_interface)
        connection_manager.CWMP_PATH = tempfile.mkdtemp()
        subprocess.set_conman_paths(tmp_dir, config_dir,
                                    connection_manager.CWMP_PATH)

        for band, access_point in wlan_configs.iteritems():
          subprocess.mock('cwmp', band, ssid='initial ssid', psk='initial psk',
                          access_point=access_point, write_now=True)

        # Test that missing directories are created by ConnectionManager.
        shutil.rmtree(tmp_dir)

        kwargs = dict(tmp_dir=tmp_dir,
                      config_dir=config_dir,
                      moca_tmp_dir=moca_tmp_dir,
                      run_duration_s=run_duration_s,
                      interface_update_period=interface_update_period,
                      wlan_retry_s=0,
                      wifi_scan_period_s=wifi_scan_period_s,
                      associate_wait_s=associate_wait_s,
                      dhcp_wait_s=dhcp_wait_s,
                      acs_connection_check_wait_s=acs_cc_wait_s,
                      acs_start_wait_s=acs_start_wait_s,
                      acs_finish_wait_s=acs_finish_wait_s,
                      bssid_cycle_length_s=1)
        kwargs.update(cm_kwargs)
        c = ConnectionManager(**kwargs)

        f(c)
      except Exception:
        logger.error('Uncaught exception!')
        traceback.print_exc()
        raise
      finally:
        if os.path.exists(connection_manager.TMP_HOSTS):
          os.unlink(connection_manager.TMP_HOSTS)
        shutil.rmtree(tmp_dir)
        shutil.rmtree(config_dir)
        shutil.rmtree(moca_tmp_dir)
        shutil.rmtree(wpa_control_interface)
        shutil.rmtree(connection_manager.CWMP_PATH)

    actual_test.func_name = f.func_name
    return actual_test

  return inner


def _enable_basic_scan_results(band):
  for bssid, ssid, ccr in (('00:11:22:33:44:55', 's1', 'fail'),
                           ('66:77:88:99:aa:bb', 's1', 'fail'),
                           ('01:23:45:67:89:ab', 's2', 'succeed')):
    subprocess.mock('wifi', 'remote_ap', bssid=bssid, ssid=ssid,
                    band=band, security=None, connection_check_result=ccr)


def _disable_basic_scan_results(band):
  for bssid in (('00:11:22:33:44:55'), ('66:77:88:99:aa:bb'),
                ('01:23:45:67:89:ab')):
    subprocess.mock('wifi', 'remote_ap_remove', bssid=bssid, band=band)


def connection_manager_test_generic(c, band):
  """Test ConnectionManager for things independent of radio configuration.

  To verify that these things are both independent, this function is called once
  below with each radio configuration.

  Args:
    c:  The ConnectionManager set up by @connection_manager_test.
    band:  The band to test.
  """
  # This test only checks that this file gets created and deleted once each.
  # ConnectionManager cares that the file is created *where* expected, but it is
  # Bridge's responsbility to make sure its creation and deletion are generally
  # correct; more thorough tests are in bridge_test in interface_test.py.
  acs_autoprov_filepath = os.path.join(c._tmp_dir, 'acs_autoprovisioning')

  # Each Wifi's provisioning ratchet has beeen created, but not started.
  wvtest.WVFAIL(c.has_status_files([status.P.TRYING_OPEN]))

  # Initially, there is ethernet access (via explicit check of ethernet status,
  # rather than the interface status file).
  wvtest.WVPASS(c.acs())
  wvtest.WVPASS(c.internet())
  wvtest.WVPASS(c.has_status_files([status.P.CAN_REACH_ACS,
                                    status.P.CAN_REACH_INTERNET]))
  hostname = connection_manager.HOSTNAME

  c.run_once()
  wvtest.WVPASS(c.acs())
  wvtest.WVPASS(c.internet())
  wvtest.WVPASS(c.bridge.current_routes())
  wvtest.WVPASS(os.path.exists(acs_autoprov_filepath))
  for wifi in c.wifi:
    wvtest.WVFAIL(wifi.current_routes_normal_testonly())
  wvtest.WVFAIL(c.has_status_files([status.P.CONNECTED_TO_WLAN,
                                    status.P.HAVE_CONFIG]))

  # Take down ethernet, no access.
  c.set_ethernet(False)
  c.run_once()
  wvtest.WVFAIL(c.acs())
  wvtest.WVFAIL(c.internet())
  wvtest.WVFAIL(c.bridge.current_routes_normal_testonly())
  wvtest.WVFAIL(os.path.exists(acs_autoprov_filepath))
  wvtest.WVFAIL(c.has_status_files([status.P.CAN_REACH_ACS,
                                    status.P.CAN_REACH_INTERNET]))

  # Bring up moca, access.
  c.set_moca(True)
  c.run_once()
  wvtest.WVPASS(c.acs())
  wvtest.WVPASS(c.internet())
  wvtest.WVPASS(c.bridge.current_routes())

  # Bring up ethernet, access via both moca and ethernet.
  c.set_ethernet(True)
  c.run_once()
  wvtest.WVPASS(c.acs())
  wvtest.WVPASS(c.internet())
  wvtest.WVPASS(c.bridge.current_routes())

  # Bring down moca, still have access via ethernet.
  c.set_moca(False)
  c.run_once()
  wvtest.WVPASS(c.acs())
  wvtest.WVPASS(c.internet())
  wvtest.WVPASS(c.bridge.current_routes())

  # The bridge interfaces are up, but they can't reach anything.
  c.bridge.set_connection_check_result('fail')
  c.run_until_interface_update()
  wvtest.WVFAIL(c.acs())
  wvtest.WVFAIL(c.internet())
  wvtest.WVFAIL(c.bridge.current_routes_normal_testonly())

  # Now c connects to a restricted network.
  c.bridge.set_connection_check_result('restricted')
  c.run_until_interface_update()
  wvtest.WVPASS(c.acs())
  wvtest.WVFAIL(c.internet())
  wvtest.WVPASS(c.bridge.current_routes())

  # Now the wired connection goes away.
  c.set_ethernet(False)
  c.set_moca(False)
  c.run_once()
  wvtest.WVFAIL(c.acs())
  wvtest.WVFAIL(c.internet())
  # We have no links, so we should have no routes (not even low priority ones),
  # and /tmp/hosts should only contain a line for localhost.
  wvtest.WVFAIL(c.bridge.current_routes())
  check_tmp_hosts('127.0.0.1 localhost')

  # Now there are some scan results.
  _enable_basic_scan_results(band)

  # Create a WLAN configuration which should eventually be connected to.
  ssid = 'wlan'
  psk = 'password'
  subprocess.mock('wifi', 'remote_ap',
                  bssid='11:22:33:44:55:66',
                  ssid=ssid, psk=psk, band=band, security='WPA2')
  subprocess.mock('cwmp', band, ssid=ssid, psk=psk, access_point=False)

  wvtest.WVFAIL(subprocess.upload_logs_and_wait.uploaded_logs())
  # Wait for a scan, then until s2 is tried.
  c.run_until_scan(band)
  subprocess.call(['ip', 'addr', 'add', '192.168.1.100',
                   'dev', c.wifi_for_band(band).name])
  for _ in range(len(c.wifi_for_band(band).cycler)):
    c.run_once()
    wvtest.WVPASS(c.has_status_files([status.P.CONNECTED_TO_OPEN]))
    last_bss_info = c.wifi_for_band(band).last_attempted_bss_info
    if last_bss_info.ssid == 's2':
      break

  wvtest.WVPASSEQ(last_bss_info.ssid, 's2')
  wvtest.WVPASSEQ(last_bss_info.bssid, '01:23:45:67:89:ab')

  # Wait for the connection to be processed.
  c.run_once()
  wvtest.WVPASS(c.acs())
  wvtest.WVPASS(c.internet())
  wvtest.WVFAIL(c.client_up(band))
  wvtest.WVPASS(c.wifi_for_band(band).current_routes())
  wvtest.WVPASS(subprocess.upload_logs_and_wait.uploaded_logs())
  c.run_until_interface_update()
  check_tmp_hosts('192.168.1.100 %s\n127.0.0.1 localhost' % hostname)

  c.run_once()
  wvtest.WVPASS(c.client_up(band))
  wvtest.WVPASS(c.wifi_for_band(band).current_routes())
  wvtest.WVPASS(c.has_status_files([status.P.CONNECTED_TO_WLAN]))

  # Kill wpa_supplicant.  conman should restart it.
  wvtest.WVPASS(c.client_up(band))
  wvtest.WVPASS(c._connected_to_wlan(c.wifi_for_band(band)))
  subprocess.mock('wifi', 'kill_wpa_supplicant', band)
  wvtest.WVFAIL(c.client_up(band))
  wvtest.WVFAIL(c._connected_to_wlan(c.wifi_for_band(band)))
  # Make sure we stay connected to s2, rather than disconnecting and
  # reconnecting.
  c.run_once()
  wvtest.WVPASS(c.has_status_files([status.P.CONNECTED_TO_WLAN]))
  wvtest.WVPASS(c.client_up(band))
  wvtest.WVPASS(c._connected_to_wlan(c.wifi_for_band(band)))

  # Now, update the WLAN configuration and make sure we reprovision.

  # The AP restarts with a new configuration, kicking us off.  We should
  # reprovision.
  ssid = 'wlan2'
  psk = 'password2'
  subprocess.mock('cwmp', band, ssid=ssid, psk=psk)
  # Overwrites previous one due to same BSSID.
  subprocess.mock('wifi', 'remote_ap',
                  bssid='11:22:33:44:55:66',
                  ssid=ssid, psk=psk, band=band, security='WPA2')
  subprocess.mock('wifi', 'disconnected_event', band)
  c.run_once()
  wvtest.WVFAIL(c.client_up(band))
  wvtest.WVPASS(c._connected_to_open(c.wifi_for_band(band)))
  wvtest.WVPASSEQ(c.wifi_for_band(band).last_attempted_bss_info.ssid, 's2')

  # Run once for cwmp wakeup to get called, then once more for the new config to
  # be received.
  c.run_once()
  c.run_once()
  wvtest.WVPASS(c.client_up(band))
  wvtest.WVPASS(c.wifi_for_band(band).wpa_status()['ssid'] == ssid)
  wvtest.WVPASS(c.has_status_files([status.P.CONNECTED_TO_WLAN]))
  wvtest.WVPASS(c.wifi_for_band(band).current_routes())

  # Now, remove the WLAN configuration and make sure we are disconnected.  Then
  # disable the previously used ACS connection via s2, re-enable scan results,
  # add the user's WLAN to the scan results, and scan again.  This time, the
  # first SSID tried should be 's3', which is now present in the scan results
  # (with its SSID hidden, but included via vendor IE).
  subprocess.mock('cwmp', band, delete_config=True, write_now=True)
  del c.wifi_for_band(band).cycler
  _enable_basic_scan_results(band)
  # Remove s2.
  subprocess.mock('wifi', 'remote_ap_remove',
                  bssid='01:23:45:67:89:ab', band=band)
  # Create s3.
  subprocess.mock('wifi', 'remote_ap', bssid='ff:ee:dd:cc:bb:aa', ssid='s3',
                  band=band, security=None, hidden=True,
                  vendor_ies=(('f4:f5:e8', '01'), ('f4:f5:e8', '03 73 33')))
  #### Now, recreate the same WLAN configuration, which should be connected to.
  subprocess.mock('cwmp', band, ssid=ssid, psk=psk)

  c.run_until_interface_update_and_scan(band)
  c.run_until_interface_update()
  wvtest.WVPASSEQ(c.wifi_for_band(band).last_attempted_bss_info.ssid, 's3')
  wvtest.WVPASSEQ(c.wifi_for_band(band).last_attempted_bss_info.bssid,
                  'ff:ee:dd:cc:bb:aa')
  wvtest.WVPASS(subprocess.upload_logs_and_wait.uploaded_logs())

  c.run_once()
  wvtest.WVPASS(c.client_up(band))
  wvtest.WVPASS(c.wifi_for_band(band).current_routes())
  wvtest.WVPASS(c.has_status_files([status.P.CONNECTED_TO_WLAN]))

  # Now enable the AP.  Since we have no wired connection, this should have no
  # effect.
  subprocess.mock('cwmp', band, access_point=True, write_now=True)
  c.run_once()
  wvtest.WVPASS(c.client_up(band))
  wvtest.WVPASS(c.wifi_for_band(band).current_routes())
  wvtest.WVFAIL(c.bridge.current_routes_normal_testonly())
  c.run_until_interface_update()
  check_tmp_hosts('192.168.1.100 %s\n127.0.0.1 localhost' % hostname)

  # Now bring up the bridge.  We should remove the wifi connection and start
  # an AP.
  c.set_ethernet(True)
  c.bridge.set_connection_check_result('succeed')
  subprocess.call(['ip', 'addr', 'add', '192.168.1.101', 'dev', c.bridge.name])
  c.run_until_interface_update()
  wvtest.WVPASS(c.access_point_up(band))
  wvtest.WVFAIL(c.client_up(band))
  wvtest.WVFAIL(c.wifi_for_band(band).current_routes())
  wvtest.WVPASS(c.bridge.current_routes())
  check_tmp_hosts('192.168.1.101 %s\n127.0.0.1 localhost' % hostname)

  # Now move (rather than delete) the configuration file.  The AP should go
  # away, and we should not be able to join the WLAN.  Routes should not be
  # affected.
  filename = subprocess.cwmp.wlan_config_filename(band)
  other_filename = filename + '.bak'
  os.rename(filename, other_filename)
  c.run_once()
  wvtest.WVFAIL(c.access_point_up(band))
  wvtest.WVFAIL(c.client_up(band))
  wvtest.WVFAIL(c.wifi_for_band(band).current_routes_normal_testonly())
  wvtest.WVPASS(c.bridge.current_routes())
  wvtest.WVFAIL(c.has_status_files([status.P.HAVE_CONFIG]))

  # Now move it back, and the AP should come back.
  os.rename(other_filename, filename)
  c.run_once()
  wvtest.WVPASS(c.access_point_up(band))
  wvtest.WVFAIL(c.client_up(band))
  wvtest.WVFAIL(c.wifi_for_band(band).current_routes_normal_testonly())
  wvtest.WVPASS(c.bridge.current_routes())

  # Now delete the config and bring down the bridge and make sure we reprovision
  # via the last working BSS.
  subprocess.mock('cwmp', band, delete_config=True, write_now=True)
  c.bridge.set_connection_check_result('fail')
  scan_count_for_band = c.wifi_for_band(band).wifi_scan_counter
  c.run_until_interface_update()
  wvtest.WVFAIL(c.acs())
  wvtest.WVFAIL(c.internet())
  # We still have a link and might be wrong about the connection_check, so
  # /tmp/hosts should still contain a line for this hostname.
  check_tmp_hosts('192.168.1.101 %s\n127.0.0.1 localhost' % hostname)
  # s3 is not what the cycler would suggest trying next.
  wvtest.WVPASSNE('s3', c.wifi_for_band(band).cycler.peek())
  subprocess.mock('cwmp', band, ssid=ssid, psk=psk)
  # Run only once, so that only one BSS can be tried.  It should be the s3 one,
  # since that worked previously.
  c.run_once()
  wvtest.WVPASS(c.acs())
  # Make sure we didn't scan on `band`.
  wvtest.WVPASSEQ(scan_count_for_band, c.wifi_for_band(band).wifi_scan_counter)
  c.run_once()
  wvtest.WVPASS(subprocess.upload_logs_and_wait.uploaded_logs())

  # Now wait for the WLAN config to be created, connect to the WLAN, and make
  # sure that s3 is unset as last_successful_bss_info, since it is no longer
  # available.
  c.run_once()
  wvtest.WVPASS(c.acs())
  wvtest.WVPASS(c.internet())

  # Remove s3.
  subprocess.mock('wifi', 'remote_ap_remove',
                  bssid='ff:ee:dd:cc:bb:aa', band=band)
  # Bring s2 back.
  subprocess.mock('wifi', 'remote_ap', bssid='01:23:45:67:89:ab', ssid='s2',
                  band=band, security=None)

  subprocess.mock('cwmp', band, delete_config=True, write_now=True)
  c.run_once()
  wvtest.WVPASSEQ(c.wifi_for_band(band).last_successful_bss_info, None)

  # Now do the same, except this time s2 is connected to but doesn't provide ACS
  # access.  This requires first re-establishing s2 as successful, so there are
  # four steps:
  #
  # 1) Connect to WLAN.
  # 2) Disconnect, reprovision via s2 (establishing it as successful).
  # 3) Reconnect to WLAN so that we can trigger re-provisioning by
  #    disconnecting.
  # 4) Connect to s2 but get no ACS access; see that last_successful_bss_info is
  #    unset.
  subprocess.mock('cwmp', band, ssid=ssid, psk=psk, write_now=True)
  # Connect
  c.run_once()
  # Process DHCP results
  c.run_once()
  wvtest.WVPASS(c.acs())
  wvtest.WVPASS(c.internet())

  subprocess.mock('cwmp', band, delete_config=True, write_now=True)
  c.run_once()
  wvtest.WVFAIL(c.wifi_for_band(band).acs())

  # Give it time to try all BSSIDs.  This means sleeping long enough that
  # everything in the cycler is active, then doing n+1 loops (the n+1st loop is
  # when we decide that the SSID in the nth loop was successful).
  time.sleep(c._bssid_cycle_length_s)
  subprocess.mock('cwmp', band, ssid=ssid, psk=psk)
  for _ in range(len(c.wifi_for_band(band).cycler) + 1):
    c.run_once()
  s2_bss = iw.BssInfo(bssid='01:23:45:67:89:ab', ssid='s2', band=band)
  wvtest.WVPASSEQ(c.wifi_for_band(band).last_successful_bss_info, s2_bss)
  c.run_once()
  wvtest.WVPASS(subprocess.upload_logs_and_wait.uploaded_logs())

  # Make s2's connection check fail.
  subprocess.mock('wifi', 'remote_ap', bssid='01:23:45:67:89:ab', ssid='s2',
                  band=band, security=None, connection_check_result='fail')

  c.run_once()
  wvtest.WVPASS(c.acs())
  wvtest.WVPASS(c.internet())
  wvtest.WVPASSEQ(c.wifi_for_band(band).last_successful_bss_info, s2_bss)
  # Disconnect.
  ssid = 'wlan3'
  psk = 'password3'
  subprocess.mock('wifi', 'remote_ap',
                  bssid='11:22:33:44:55:66',
                  ssid=ssid, psk=psk, band=band, security='WPA2')
  subprocess.mock('wifi', 'disconnected_event', band)
  # Run once so that c will reconnect to s2.
  c.run_once()
  wvtest.WVPASS(c.wifi_for_band(band).connected_to_open())
  wvtest.WVPASSEQ(c.wifi_for_band(band).wpa_status().get('ssid'), 's2')
  # Now run until it sees the lack of ACS access.
  c.run_until_interface_update()
  wvtest.WVPASSEQ(c.wifi_for_band(band).last_successful_bss_info, None)

  # Test that we wait dhcp_wait_s seconds for a DHCP lease before trying the
  # next BSSID.  The scan results contain an s3 AP with vendor IEs that fails to
  # send a DHCP lease.  This ensures that s3 will be tried before any other AP,
  # which lets us force a timeout and proceed to the next AP.  Having a stale
  # WLAN configuration shouldn't interrupt provisioning.
  del c.wifi_for_band(band).cycler
  subprocess.mock('wifi', 'remote_ap', bssid='ff:ee:dd:cc:bb:aa', ssid='s3',
                  band=band, security=None, hidden=True,
                  vendor_ies=(('f4:f5:e8', '01'), ('f4:f5:e8', '03 73 33')))
  subprocess.mock('run-dhclient', c.wifi_for_band(band).name, failure=True)

  # First iteration: check that we try s3.
  c.run_until_scan(band)
  last_bss_info = c.wifi_for_band(band).last_attempted_bss_info
  wvtest.WVPASSEQ(last_bss_info.ssid, 's3')
  wvtest.WVPASSEQ(last_bss_info.bssid, 'ff:ee:dd:cc:bb:aa')
  # Attempt to interrupt provisioning, make sure it doesn't work.
  c._wlan_configuration[band].try_after = 0
  # Second iteration: check that we try s3 again since there's no gateway yet.
  c.run_once()
  last_bss_info = c.wifi_for_band(band).last_attempted_bss_info
  wvtest.WVPASSEQ(last_bss_info.ssid, 's3')
  wvtest.WVPASSEQ(last_bss_info.bssid, 'ff:ee:dd:cc:bb:aa')
  wvtest.WVPASS(c.has_status_files([status.P.WAITING_FOR_DHCP,
                                    status.P.WAITING_FOR_PROVISIONING]))
  # Third iteration: sleep for dhcp_wait_s and check that we try another AP.
  time.sleep(c._dhcp_wait_s)
  c.run_once()
  last_bss_info = c.wifi_for_band(band).last_attempted_bss_info
  wvtest.WVPASSNE(last_bss_info.ssid, 's3')
  wvtest.WVPASSNE(last_bss_info.bssid, 'ff:ee:dd:cc:bb:aa')

  # We can delete the stale WLAN config now, to simplify subsequent tests.
  # c.delete_wlan_config(band)
  subprocess.mock('cwmp', band, delete_config=True, write_now=True)

  # Now repeat the above, but for an ACS session that takes a while.  We don't
  # necessarily want to leave if it fails (so we don't want the third check),
  # but we do want to make sure we don't leave while we're still waiting for it.
  #
  # Unlike DHCP, which we can always simulate working immediately above, it is
  # wrong to simulate ACS sessions working for connections without ACS access.
  # This means we can either always wait for the ACS session timeout in every
  # test above, making the tests much slower, or we can set that timeout very
  # low and then be a little gross here and change it.  The latter is
  # unfortunately the lesser evil, because slow tests are bad.
  del c.wifi_for_band(band).cycler
  subprocess.mock('run-dhclient', c.wifi_for_band(band).name, failure=False)
  subprocess.mock('cwmp', band, acs_session_fails=True)

  # First iteration: check that we try s3.
  c.run_until_scan(band)
  last_bss_info = c.wifi_for_band(band).last_attempted_bss_info
  wvtest.WVPASSEQ(last_bss_info.ssid, 's3')
  wvtest.WVPASSEQ(last_bss_info.bssid, 'ff:ee:dd:cc:bb:aa')

  # This is the gross part.
  # pylint: disable=protected-access
  c.wifi_for_band(band).provisioning_ratchet.steps[3].timeout = 0.5

  # Second iteration: check that we don't leave while waiting.
  c.run_once()
  last_bss_info = c.wifi_for_band(band).last_attempted_bss_info
  wvtest.WVPASSEQ(last_bss_info.ssid, 's3')
  wvtest.WVPASSEQ(last_bss_info.bssid, 'ff:ee:dd:cc:bb:aa')
  wvtest.WVPASS(c.has_status_files([status.P.WAITING_FOR_ACS_SESSION,
                                    status.P.WAITING_FOR_PROVISIONING]))
  time.sleep(0.5)
  c.run_once()
  wvtest.WVPASS(c.has_status_files([status.P.PROVISIONING_FAILED]))
  c.wifi_for_band(band).provisioning_ratchet.steps[3].timeout = 0

  # Finally, test successful provisioning.
  del c.wifi_for_band(band).cycler
  subprocess.mock('cwmp', band, acs_session_fails=False)
  # First iteration: check that we try s3.
  c.run_until_scan(band)
  last_bss_info = c.wifi_for_band(band).last_attempted_bss_info
  wvtest.WVPASSEQ(last_bss_info.ssid, 's3')
  wvtest.WVPASSEQ(last_bss_info.bssid, 'ff:ee:dd:cc:bb:aa')

  c.run_once()
  last_bss_info = c.wifi_for_band(band).last_attempted_bss_info
  wvtest.WVPASSEQ(last_bss_info.ssid, 's3')
  wvtest.WVPASSEQ(last_bss_info.bssid, 'ff:ee:dd:cc:bb:aa')
  wvtest.WVFAIL(c.has_status_files([status.P.WAITING_FOR_ACS_SESSION,
                                    status.P.WAITING_FOR_PROVISIONING]))
  wvtest.WVPASS(c.has_status_files([status.P.PROVISIONING_COMPLETED]))


@test_common.wvtest
@connection_manager_test(WIFI_SHOW_OUTPUT_MARVELL8897)
def connection_manager_test_generic_marvell8897_2g(c):
  connection_manager_test_generic(c, '2.4')


@test_common.wvtest
@connection_manager_test(WIFI_SHOW_OUTPUT_MARVELL8897)
def connection_manager_test_generic_marvell8897_5g(c):
  connection_manager_test_generic(c, '5')


@test_common.wvtest
@connection_manager_test(WIFI_SHOW_OUTPUT_ATH9K_ATH10K)
def connection_manager_test_generic_ath9k_ath10k_2g(c):
  connection_manager_test_generic(c, '2.4')


@test_common.wvtest
@connection_manager_test(WIFI_SHOW_OUTPUT_ATH9K_ATH10K)
def connection_manager_test_generic_ath9k_ath10k_5g(c):
  connection_manager_test_generic(c, '5')


@test_common.wvtest
@connection_manager_test(WIFI_SHOW_OUTPUT_ATH9K_FRENZY)
def connection_manager_test_generic_ath9k_frenzy_2g(c):
  connection_manager_test_generic(c, '2.4')


@test_common.wvtest
@connection_manager_test(WIFI_SHOW_OUTPUT_ATH9K_FRENZY)
def connection_manager_test_generic_ath9k_frenzy_5g(c):
  connection_manager_test_generic(c, '5')


@test_common.wvtest
@connection_manager_test(WIFI_SHOW_OUTPUT_FRENZY)
def connection_manager_test_generic_frenzy_5g(c):
  connection_manager_test_generic(c, '5')


def connection_manager_test_dual_band_two_radios(c):
  """Test ConnectionManager for devices with two radios.

  This test should be kept roughly parallel to the one-radio test.

  Args:
    c:  The ConnectionManager set up by @connection_manager_test.
  """
  ssid = 'my ssid'
  psk = 'passphrase'

  wvtest.WVPASSEQ(len(c._binwifi_commands), 2)

  for band in ['2.4', '5']:
    wvtest.WVPASS(('stop', '--band', band, '--persist') in c._binwifi_commands)

    subprocess.mock('wifi', 'remote_ap',
                    bssid='11:22:33:44:55:66',
                    ssid=ssid, psk=psk, band=band, security='WPA2')

  # Bring up ethernet, access.
  c.set_ethernet(True)
  c.run_once()
  wvtest.WVPASS(c.acs())
  wvtest.WVPASS(c.internet())

  # Bring up both access points.
  for band in ('2.4', '5'):
    subprocess.mock('cwmp', band, ssid=ssid, psk=psk, access_point=True,
                    write_now=True)
  c.run_once()
  wvtest.WVPASS(c.access_point_up('2.4'))
  wvtest.WVPASS(c.access_point_up('5'))
  wvtest.WVPASS(c.bridge.current_routes())
  wvtest.WVFAIL(c.client_up('2.4'))
  wvtest.WVFAIL(c.client_up('5'))
  wvtest.WVFAIL(c.wifi_for_band('2.4').current_routes_normal_testonly())
  wvtest.WVFAIL(c.wifi_for_band('5').current_routes_normal_testonly())

  # Disable the 2.4 GHz AP, make sure the 5 GHz AP stays up.  2.4 GHz should
  # join the WLAN.
  subprocess.mock('cwmp', '2.4', access_point=False, write_now=True)
  c.run_until_interface_update()
  wvtest.WVFAIL(c.access_point_up('2.4'))
  wvtest.WVPASS(c.access_point_up('5'))
  wvtest.WVPASS(c.client_up('2.4'))
  wvtest.WVPASS(c.bridge.current_routes())
  wvtest.WVPASS(c.wifi_for_band('2.4').current_routes())
  wvtest.WVFAIL(c.wifi_for_band('5').current_routes_normal_testonly())

  # Delete the 2.4 GHz WLAN configuration; it should leave the WLAN but nothing
  # else should change.
  subprocess.mock('cwmp', '2.4', delete_config=True, write_now=True)
  c.run_until_interface_update()
  wvtest.WVFAIL(c.access_point_up('2.4'))
  wvtest.WVPASS(c.access_point_up('5'))
  wvtest.WVFAIL(c.client_up('2.4'))
  wvtest.WVPASS(c.bridge.current_routes())
  wvtest.WVFAIL(c.wifi_for_band('2.4').current_routes_normal_testonly())
  wvtest.WVFAIL(c.wifi_for_band('5').current_routes_normal_testonly())

  # Disable the wired connection and remove the WLAN configurations.  Both
  # radios should scan.  Wait for 5 GHz to scan, then enable scan results for
  # 2.4. This should lead to ACS access.
  subprocess.mock('cwmp', '5', delete_config=True, write_now=True)
  c.set_ethernet(False)
  c.run_once()
  wvtest.WVFAIL(c.acs())
  wvtest.WVFAIL(c.bridge.current_routes_normal_testonly())
  wvtest.WVFAIL(c.wifi_for_band('2.4').current_routes_normal_testonly())
  wvtest.WVFAIL(c.wifi_for_band('5').current_routes_normal_testonly())

  # The 5 GHz scan has no results.
  c.run_until_scan('5')
  c.run_once()
  c.run_until_interface_update()
  wvtest.WVFAIL(c.acs())
  wvtest.WVFAIL(c.bridge.current_routes_normal_testonly())
  wvtest.WVFAIL(c.wifi_for_band('2.4').current_routes_normal_testonly())
  wvtest.WVFAIL(c.wifi_for_band('5').current_routes_normal_testonly())

  # The next 2.4 GHz scan will have results.
  _enable_basic_scan_results('2.4')
  c.run_until_scan('2.4')
  # Now run for enough cycles that s2 will have been tried.
  for _ in range(len(c.wifi_for_band('2.4').cycler)):
    c.run_once()
  c.run_until_interface_update()
  wvtest.WVPASS(c.acs())
  wvtest.WVFAIL(c.bridge.current_routes_normal_testonly())
  wvtest.WVPASS(c.wifi_for_band('2.4').current_routes())
  wvtest.WVFAIL(c.wifi_for_band('5').current_routes_normal_testonly())
  c.run_once()
  wvtest.WVPASS(subprocess.upload_logs_and_wait.uploaded_logs())


@test_common.wvtest
@connection_manager_test(WIFI_SHOW_OUTPUT_ATH9K_ATH10K)
def connection_manager_test_dual_band_two_radios_ath9k_ath10k(c):
  connection_manager_test_dual_band_two_radios(c)


@test_common.wvtest
@connection_manager_test(WIFI_SHOW_OUTPUT_ATH9K_FRENZY)
def connection_manager_test_dual_band_two_radios_ath9k_frenzy(c):
  connection_manager_test_dual_band_two_radios(c)


def connection_manager_test_dual_band_one_radio(c):
  """Test ConnectionManager for devices with one dual-band radio.

  This test should be kept roughly parallel to
  connection_manager_test_dual_band_two_radios.

  Args:
    c:  The ConnectionManager set up by @connection_manager_test.
  """
  wvtest.WVPASSEQ(len(c._binwifi_commands), 1)
  wvtest.WVPASSEQ(('stop', '--band', '5', '--persist'), c._binwifi_commands[0])

  # Bring up ethernet, access.
  c.set_ethernet(True)
  c.run_once()
  wvtest.WVPASS(c.acs())
  wvtest.WVPASS(c.internet())

  ssid = 'my ssid'
  psk = 'passphrase'

  # Enable both access points.  Only 5 should be up.
  subprocess.mock('cwmp', '2.4', ssid=ssid, psk=psk, access_point=True,
                  write_now=True)
  subprocess.mock('cwmp', '5', ssid=ssid, psk=psk, access_point=True,
                  write_now=True)
  c.run_once()
  wvtest.WVFAIL(c.access_point_up('2.4'))
  wvtest.WVPASS(c.access_point_up('5'))
  wvtest.WVPASS(c.bridge.current_routes())
  wvtest.WVFAIL(c.wifi_for_band('2.4').current_routes_normal_testonly())
  wvtest.WVFAIL(c.wifi_for_band('5').current_routes_normal_testonly())

  # Disable the 2.4 GHz AP; nothing should change.  The 2.4 GHz client should
  # not be up because the same radio is being used to run a 5 GHz AP.
  subprocess.mock('cwmp', '2.4', access_point=False, write_now=True)
  c.run_until_interface_update()
  wvtest.WVFAIL(c.access_point_up('2.4'))
  wvtest.WVPASS(c.access_point_up('5'))
  wvtest.WVFAIL(c.client_up('2.4'))
  wvtest.WVPASS(c.bridge.current_routes())
  wvtest.WVFAIL(c.wifi_for_band('2.4').current_routes_normal_testonly())
  wvtest.WVFAIL(c.wifi_for_band('5').current_routes_normal_testonly())

  # Delete the 2.4 GHz WLAN configuration; nothing should change.
  subprocess.mock('cwmp', '2.4', delete_config=True, write_now=True)
  c.run_once()
  wvtest.WVFAIL(c.access_point_up('2.4'))
  wvtest.WVPASS(c.access_point_up('5'))
  wvtest.WVFAIL(c.client_up('2.4'))
  wvtest.WVPASS(c.bridge.current_routes())
  wvtest.WVFAIL(c.wifi_for_band('2.4').current_routes_normal_testonly())
  wvtest.WVFAIL(c.wifi_for_band('5').current_routes_normal_testonly())

  # Disable the wired connection and remove the WLAN configurations.  There
  # should be a single scan that leads to ACS access.  (It doesn't matter which
  # band we specify in run_until_scan, since both bands point to the same
  # interface.)
  subprocess.mock('cwmp', '5', delete_config=True, write_now=True)
  c.set_ethernet(False)
  c.run_once()
  wvtest.WVFAIL(c.acs())
  wvtest.WVFAIL(c.bridge.current_routes_normal_testonly())
  wvtest.WVFAIL(c.wifi_for_band('2.4').current_routes_normal_testonly())
  wvtest.WVFAIL(c.wifi_for_band('5').current_routes_normal_testonly())

  # The scan will have results that will lead to ACS access.
  _enable_basic_scan_results('2.4')
  c.run_until_scan('5')
  for _ in range(len(c.wifi_for_band('2.4').cycler)):
    c.run_once()
  c.run_until_interface_update()
  wvtest.WVPASS(c.acs())
  wvtest.WVFAIL(c.bridge.current_routes_normal_testonly())
  wvtest.WVPASS(c.wifi_for_band('2.4').current_routes())
  wvtest.WVPASS(c.wifi_for_band('5').current_routes())
  c.run_once()
  wvtest.WVPASS(subprocess.upload_logs_and_wait.uploaded_logs())


@test_common.wvtest
@connection_manager_test(WIFI_SHOW_OUTPUT_MARVELL8897)
def connection_manager_test_dual_band_one_radio_marvell8897(c):
  connection_manager_test_dual_band_one_radio(c)


@test_common.wvtest
@connection_manager_test(WIFI_SHOW_OUTPUT_MARVELL8897_NO_5GHZ)
def connection_manager_test_marvell8897_no_5ghz(c):
  """Test ConnectionManager for the case documented in b/27328894.

  conman should be able to handle the lack of 5 GHz without actually
  crashing.  Wired connections should not be affected.

  Args:
    c:  The ConnectionManager set up by @connection_manager_test.
  """
  # Make sure we've correctly set up the test; that there is no 5 GHz wifi
  # interface.
  ssid = 'my ssid'
  psk = 'my psk'
  subprocess.mock('wifi', 'remote_ap', band='2.4', ssid=ssid, psk=psk,
                  bssid='00:00:00:00:00:00', security='WPA2',
                  connection_check_result='succeed')

  wvtest.WVPASSEQ(c.wifi_for_band('5'), None)

  c.set_ethernet(True)
  wvtest.WVPASS(c.acs())
  wvtest.WVPASS(c.internet())

  # Make sure this doesn't crash.
  subprocess.mock('cwmp', '5', ssid=ssid, psk=psk, write_now=True)
  c.run_once()
  subprocess.mock('cwmp', '5', access_point=True, write_now=True)
  c.run_once()
  subprocess.mock('cwmp', '5', access_point=False, write_now=True)
  c.run_once()
  subprocess.mock('cwmp', '5', delete_config=True, write_now=True)
  c.run_once()

  # Make sure 2.4 still works.
  subprocess.mock('cwmp', '2.4', ssid=ssid, psk=psk, write_now=True)
  # Connect
  c.run_once()
  # Process DHCP results
  c.run_once()
  wvtest.WVPASS(c.wifi_for_band('2.4').acs())
  wvtest.WVPASS(c.wifi_for_band('2.4').internet())
  wvtest.WVPASS(c.wifi_for_band('2.4').current_routes())


@test_common.wvtest
@connection_manager_test(WIFI_SHOW_OUTPUT_MARVELL8897,
                         __test_interfaces_already_up=['eth0', 'wcli0'])
def connection_manager_test_wifi_already_up(c):
  """Test ConnectionManager when wifi is already up.

  Args:
    c:  The ConnectionManager set up by @connection_manager_test.
  """
  wvtest.WVPASS(c._connected_to_wlan(c.wifi_for_band('2.4')))
  wvtest.WVPASS(c.wifi_for_band('2.4').current_routes())


@test_common.wvtest
@connection_manager_test(WIFI_SHOW_OUTPUT_MARVELL8897, wlan_configs={'5': True})
def connection_manager_one_radio_marvell8897_existing_config_5g_ap(c):
  wvtest.WVPASSEQ(len(c._binwifi_commands), 1)
  wvtest.WVPASSEQ(('stopclient', '--band', '5', '--persist'),
                  c._binwifi_commands[0])


@test_common.wvtest
@connection_manager_test(WIFI_SHOW_OUTPUT_MARVELL8897,
                         wlan_configs={'5': False})
def connection_manager_one_radio_marvell8897_existing_config_5g_no_ap(c):
  wvtest.WVPASSEQ(len(c._binwifi_commands), 1)
  wvtest.WVPASSEQ(('stopap', '--band', '5', '--persist'),
                  c._binwifi_commands[0])


@test_common.wvtest
@connection_manager_test(WIFI_SHOW_OUTPUT_ATH9K_ATH10K,
                         wlan_configs={'5': True})
def connection_manager_two_radios_ath9k_ath10k_existing_config_5g_ap(c):
  wvtest.WVPASSEQ(len(c._binwifi_commands), 2)
  wvtest.WVPASS(('stop', '--band', '2.4', '--persist') in c._binwifi_commands)
  wvtest.WVPASS(('stopclient', '--band', '5', '--persist')
                in c._binwifi_commands)


@test_common.wvtest
@connection_manager_test(WIFI_SHOW_OUTPUT_MARVELL8897)
def connection_manager_conman_no_2g_wlan(c):
  unused_raii = experiment_testutils.MakeExperimentDirs()

  # First, establish that we connect on 2.4 without the experiment, to make sure
  # this test doesn't spuriously pass.
  ssid = 'my ssid'
  psk = 'my psk'
  subprocess.mock('wifi', 'remote_ap', ssid=ssid, psk=psk, band='2.4',
                  bssid='00:00:00:00:00:00')
  subprocess.mock('cwmp', '2.4', ssid=ssid, psk=psk, write_now=True)
  c.run_once()
  wvtest.WVPASS(c.client_up('2.4'))

  # Now, force a disconnect by deleting the config.
  subprocess.mock('cwmp', '2.4', delete_config=True, write_now=True)
  c.run_once()
  wvtest.WVFAIL(c.client_up('2.4'))

  # Now enable the experiment, recreate the config, and make sure we don't
  # connect.
  experiment_testutils.enable('WifiNo2GClient')
  subprocess.mock('cwmp', '2.4', ssid=ssid, psk=psk, write_now=True)
  c.run_once()
  wvtest.WVFAIL(c.client_up('2.4'))


@test_common.wvtest
@connection_manager_test(WIFI_SHOW_OUTPUT_MARVELL8897,
                         wlan_configs={'5': False}, wlan_retry_s=30,
                         __test_interfaces_already_up=[])
def test_regression_b29364958(c):
  def count_setclient_calls():
    return len([1 for cmd, _ in subprocess.CALL_HISTORY
                if 'wifi' in cmd and 'setclient' in cmd])

  wvtest.WVPASSEQ(1, count_setclient_calls())
  for _ in range(10):
    c.run_once()
  wvtest.WVPASSEQ(1, count_setclient_calls())


if __name__ == '__main__':
  wvtest.wvtest_main()