Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 485ceb85 authored by Eric Rowe's avatar Eric Rowe
Browse files

Fix wifi association tests 

Before fix, test assumed that it was already connected to wifi so remove
these assertions.  Also, since association test may be used against
access points with no outside connectivity, remove the ping test to
8.8.8.8 at the end.

Change-Id: I3d4f3d752b72028f642da9f8e9adda4ad18a6a56
parent 86e15557

core/tests/ConnectivityManagerTest/src/com/android/connectivitymanagertest/WifiAssociationTestRunner.java

+0 −38
Original line number Diff line number Diff line
@@ -16,17 +16,12 @@ 


package com.android.connectivitymanagertest;



import android.content.Context;

import android.net.wifi.WifiManager;

import android.os.Bundle;

import android.test.InstrumentationTestRunner;

import android.test.InstrumentationTestSuite;

import android.util.Log;



import com.android.connectivitymanagertest.functional.WifiAssociationTest;



import junit.framework.TestSuite;

import junit.framework.Assert;



/**

 * Instrumentation Test Runner for wifi association test.
@@ -39,8 +34,6 @@ import junit.framework.Assert; 
 * -w com.android.connectivitymanagertest/.WifiAssociationTestRunner"

 */

public class WifiAssociationTestRunner extends InstrumentationTestRunner {

    private static final String TAG = "WifiAssociationTestRunner";

    public int mBand;



    @Override

    public TestSuite getAllTests() {
@@ -53,35 +46,4 @@ public class WifiAssociationTestRunner extends InstrumentationTestRunner { 
    public ClassLoader getLoader() {

        return WifiAssociationTestRunner.class.getClassLoader();

    }



    @Override

    public void onCreate(Bundle icicle) {

        super.onCreate(icicle);

        String mFrequencyBand = icicle.getString("frequency-band");

        if (mFrequencyBand != null) {

            setFrequencyBand(mFrequencyBand);

        }

    }



    private void setFrequencyBand(String band) {

        WifiManager mWifiManager = (WifiManager)getContext().getSystemService(Context.WIFI_SERVICE);

        if (band.equals("2.4")) {

            Log.v(TAG, "set frequency band to 2.4");

            mBand = WifiManager.WIFI_FREQUENCY_BAND_2GHZ;

        } else if (band.equals("5.0")) {

            Log.v(TAG, "set frequency band to 5.0");

            mBand = WifiManager.WIFI_FREQUENCY_BAND_5GHZ;

        } else if (band.equals("auto")) {

            Log.v(TAG, "set frequency band to auto");

            mBand = WifiManager.WIFI_FREQUENCY_BAND_AUTO;

        } else {

            Assert.fail("invalid frequency band");

        }

        int currentFreq = mWifiManager.getFrequencyBand();

        if (mBand == currentFreq) {

            Log.v(TAG, "frequency band has been set");

            return;

        }

        mWifiManager.setFrequencyBand(mBand, true);

    }

}

core/tests/ConnectivityManagerTest/src/com/android/connectivitymanagertest/functional/WifiAssociationTest.java

+69 −56
Original line number Diff line number Diff line
@@ -16,14 +16,13 @@ 


package com.android.connectivitymanagertest.functional;



import android.net.ConnectivityManager;

import android.net.NetworkInfo.State;

import android.net.wifi.WifiConfiguration;

import android.net.wifi.WifiConfiguration.AuthAlgorithm;

import android.net.wifi.WifiConfiguration.GroupCipher;

import android.net.wifi.WifiConfiguration.PairwiseCipher;

import android.net.wifi.WifiConfiguration.Protocol;

import android.net.wifi.WifiInfo;

import android.net.wifi.WifiManager;

import android.os.Bundle;

import android.test.suitebuilder.annotation.LargeTest;
@@ -39,13 +38,7 @@ import com.android.connectivitymanagertest.WifiConfigurationHelper; 
 * -w com.android.connectivitymanagertest/.WifiAssociationTestRunner"

 */

public class WifiAssociationTest extends ConnectivityManagerTestBase {

    private String mSsid = null;

    private String mPassword = null;

    private String mSecurityType = null;

    private String mFrequencyBand = null;

    private int mBand;



    enum SECURITY_TYPE {

    private enum SecurityType {

        OPEN, WEP64, WEP128, WPA_TKIP, WPA2_AES

    }
@@ -53,86 +46,106 @@ public class WifiAssociationTest extends ConnectivityManagerTestBase { 
        super(WifiAssociationTest.class.getSimpleName());

    }



    @Override

    protected void setUp() throws Exception {

        super.setUp();

    /**

     * Test that the wifi can associate with a given access point.

     */

    @LargeTest

    public void testWifiAssociation() {

        WifiAssociationTestRunner runner = (WifiAssociationTestRunner) getInstrumentation();

        Bundle arguments = runner.getArguments();

        mSecurityType = arguments.getString("security-type");

        mSsid = arguments.getString("ssid");

        mPassword = arguments.getString("password");

        mFrequencyBand = arguments.getString("frequency-band");

        mBand = runner.mBand;

        assertNotNull("security type is empty", mSecurityType);

        assertNotNull("ssid is empty", mSsid);

        validateFrequencyBand();



        // enable wifi and verify wpa_supplicant is started



        String ssid = arguments.getString("ssid");

        assertNotNull("ssid is empty", ssid);



        String securityTypeStr = arguments.getString("security-type");

        assertNotNull("security-type is empty", securityTypeStr);

        SecurityType securityType = SecurityType.valueOf(securityTypeStr);



        String password = arguments.getString("password");



        String freqStr = arguments.getString("frequency-band");

        if (freqStr != null) {

            setFrequencyBand(freqStr);

        }



        assertTrue("enable Wifi failed", enableWifi());

        assertTrue("wifi not connected", waitForNetworkState(

                ConnectivityManager.TYPE_WIFI, State.CONNECTED, LONG_TIMEOUT));

        WifiInfo wi = mWifiManager.getConnectionInfo();

        logv("%s", wi);

        assertNotNull("no active wifi info", wi);

        assertTrue("failed to ping wpa_supplicant ", mWifiManager.pingSupplicant());



        WifiConfiguration config = getConfig(ssid, securityType, password);



        logv("Network config: %s", config.toString());

        connectToWifi(config);

    }



    private void validateFrequencyBand() {

        if (mFrequencyBand != null) {

            int currentFreq = mWifiManager.getFrequencyBand();

            logv("read frequency band: " + currentFreq);

            assertEquals("specified frequency band does not match operational band of WifiManager",

                    currentFreq, mBand);

    /**

     * Set the frequency band and verify that it has been set.

     */

    private void setFrequencyBand(String frequencyBandStr) {

        int frequencyBand = -1;

        if ("2.4".equals(frequencyBandStr)) {

            frequencyBand = WifiManager.WIFI_FREQUENCY_BAND_2GHZ;

        } else if ("5.0".equals(frequencyBandStr)) {

            frequencyBand = WifiManager.WIFI_FREQUENCY_BAND_5GHZ;

        } else if ("auto".equals(frequencyBandStr)) {

            frequencyBand = WifiManager.WIFI_FREQUENCY_BAND_AUTO;

        } else {

            fail("Invalid frequency-band");

        }

        if (mWifiManager.getFrequencyBand() != frequencyBand) {

            logv("Set frequency band to %s", frequencyBandStr);

            mWifiManager.setFrequencyBand(frequencyBand, true);

        }

        assertEquals("Specified frequency band does not match operational band",

                frequencyBand, mWifiManager.getFrequencyBand());

    }



    @LargeTest

    public void testWifiAssociation() {

        assertNotNull("no test ssid", mSsid);

    /**

     * Get the {@link WifiConfiguration} based on ssid, security, and password.

     */

    private WifiConfiguration getConfig(String ssid, SecurityType securityType, String password) {

        logv("Security type is %s", securityType.toString());



        WifiConfiguration config = null;

        SECURITY_TYPE security = SECURITY_TYPE.valueOf(mSecurityType);

        logv("Security type is " + security.toString());

        switch (security) {

            // set network configurations

        switch (securityType) {

            case OPEN:

                config = WifiConfigurationHelper.createOpenConfig(mSsid);

                config = WifiConfigurationHelper.createOpenConfig(ssid);

                break;

            case WEP64:

                assertNotNull("password is empty", mPassword);

                assertNotNull("password is empty", password);

                // always use hex pair for WEP-40

                assertTrue(WifiConfigurationHelper.isHex(mPassword, 10));

                config = WifiConfigurationHelper.createWepConfig(mSsid, mPassword);

                assertTrue(WifiConfigurationHelper.isHex(password, 10));

                config = WifiConfigurationHelper.createWepConfig(ssid, password);

                config.allowedGroupCiphers.set(GroupCipher.WEP40);

                break;

            case WEP128:

                assertNotNull("password is empty", mPassword);

                assertNotNull("password is empty", password);

                // always use hex pair for WEP-104

                assertTrue(WifiConfigurationHelper.isHex(mPassword, 26));

                config = WifiConfigurationHelper.createWepConfig(mSsid, mPassword);

                assertTrue(WifiConfigurationHelper.isHex(password, 26));

                config = WifiConfigurationHelper.createWepConfig(ssid, password);

                config.allowedGroupCiphers.set(GroupCipher.WEP104);

                break;

            case WPA_TKIP:

                assertNotNull("password is empty", mPassword);

                config = WifiConfigurationHelper.createPskConfig(mSsid, mPassword);

                assertNotNull("password is empty", password);

                config = WifiConfigurationHelper.createPskConfig(ssid, password);

                config.allowedAuthAlgorithms.set(AuthAlgorithm.OPEN);

                config.allowedProtocols.set(Protocol.WPA);

                config.allowedPairwiseCiphers.set(PairwiseCipher.TKIP);

                config.allowedGroupCiphers.set(GroupCipher.TKIP);

                break;

            case WPA2_AES:

                assertNotNull("password is empty", mPassword);

                config = WifiConfigurationHelper.createPskConfig(mSsid, mPassword);

                assertNotNull("password is empty", password);

                config = WifiConfigurationHelper.createPskConfig(ssid, password);

                config.allowedAuthAlgorithms.set(AuthAlgorithm.OPEN);

                config.allowedProtocols.set(Protocol.RSN);

                config.allowedPairwiseCiphers.set(PairwiseCipher.CCMP);

                config.allowedGroupCiphers.set(GroupCipher.CCMP);

                break;

            default:

                fail("Not a valid security type: " + mSecurityType);

                fail("Not a valid security type: " + securityType);

                break;

        }

        logv("network config: %s", config.toString());

        connectToWifi(config);

        // verify that connection actually works

        assertTrue("no network connectivity at end of test", checkNetworkConnectivity());

        return config;

    }

}