Remove wifi related unit tests in SettingsLib

/*

 * Copyright (C) 2015 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

package com.android.settingslib.wifi;

import android.net.wifi.ScanResult;

import android.net.wifi.WifiConfiguration;

import android.net.wifi.WifiInfo;

import com.android.settingslib.BaseTest;

import com.android.settingslib.wifi.AccessPoint.AccessPointListener;

import org.mockito.ArgumentCaptor;

import org.mockito.Mockito;

// TODO: Add some coverage

public class AccessPointTest extends BaseTest {

    private static final String TEST_SSID = "TestSsid";

    private static final int NETWORK_ID = 0;

    private AccessPointListener mAccessPointListener;

    private AccessPoint mAccessPoint;

    @Override

    protected void setUp() throws Exception {

        super.setUp();

        mAccessPointListener = Mockito.mock(AccessPointListener.class);

        WifiConfiguration wifiConfig = new WifiConfiguration();

        wifiConfig.networkId = NETWORK_ID;

        wifiConfig.SSID = TEST_SSID;

        mAccessPoint = new AccessPoint(mContext, wifiConfig);

        mAccessPoint.setListener(mAccessPointListener);

    }

    public void testOnLevelChanged() {

        ScanResult result = new ScanResult();

        result.capabilities = "";

        result.SSID = TEST_SSID;

        // Give it a level.

        result.level = WifiTrackerTest.levelToRssi(1);

        mAccessPoint.update(result);

        verifyOnLevelChangedCallback(1);

        // Give it a better level.

        result.level = WifiTrackerTest.levelToRssi(2);

        mAccessPoint.update(result);

        verifyOnLevelChangedCallback(1);

    }

    public void testOnAccessPointChangedCallback() {

        WifiInfo wifiInfo = Mockito.mock(WifiInfo.class);

        Mockito.when(wifiInfo.getNetworkId()).thenReturn(NETWORK_ID);

        mAccessPoint.update(wifiInfo, null);

        verifyOnAccessPointsCallback(1);

        mAccessPoint.update(null, null);

        verifyOnAccessPointsCallback(2);

        ScanResult result = new ScanResult();

        result.capabilities = "";

        result.SSID = TEST_SSID;

        mAccessPoint.update(result);

        verifyOnAccessPointsCallback(3);

    }

    private void verifyOnLevelChangedCallback(int num) {

        ArgumentCaptor<AccessPoint> accessPoint = ArgumentCaptor.forClass(AccessPoint.class);

        Mockito.verify(mAccessPointListener, Mockito.atLeast(num))

                .onLevelChanged(accessPoint.capture());

        assertEquals(mAccessPoint, accessPoint.getValue());

    }

    private void verifyOnAccessPointsCallback(int num) {

        ArgumentCaptor<AccessPoint> accessPoint = ArgumentCaptor.forClass(AccessPoint.class);

        Mockito.verify(mAccessPointListener, Mockito.atLeast(num))

                .onAccessPointChanged(accessPoint.capture());

        assertEquals(mAccessPoint, accessPoint.getValue());

    }

}

/*

 * Copyright (C) 2015 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

package com.android.settingslib.wifi;

import android.content.Intent;

import android.net.NetworkInfo;

import android.net.NetworkInfo.State;

import android.net.wifi.ScanResult;

import android.net.wifi.WifiConfiguration;

import android.net.wifi.WifiInfo;

import android.net.wifi.WifiManager;

import android.net.wifi.WifiSsid;

import android.os.HandlerThread;

import android.os.Looper;

import android.util.Log;

import com.android.settingslib.BaseTest;

import com.android.settingslib.wifi.WifiTracker.Scanner;

import com.android.settingslib.wifi.WifiTracker.WifiListener;

import org.mockito.ArgumentCaptor;

import org.mockito.Mockito;

import java.io.PrintWriter;

import java.io.StringWriter;

import java.util.ArrayList;

import java.util.List;

public class WifiTrackerTest extends BaseTest {

    private static final String TAG = "WifiTrackerTest";

    private static final String[] TEST_SSIDS = new String[] {

        "TEST_SSID_1",

        "TEST_SSID_2",

        "TEST_SSID_3",

        "TEST_SSID_4",

        "TEST_SSID_5",

    };

    private static final int NUM_NETWORKS = 5;

    private WifiManager mWifiManager;

    private WifiListener mWifiListener;

    private WifiTracker mWifiTracker;

    private HandlerThread mWorkerThread;

    private Looper mLooper;

    private HandlerThread mMainThread;

    private Looper mMainLooper;

    @Override

    protected void setUp() throws Exception {

        super.setUp();

        mWifiManager = Mockito.mock(WifiManager.class);

        mWifiListener = Mockito.mock(WifiListener.class);

        mWorkerThread = new HandlerThread("TestHandlerThread");

        mWorkerThread.start();

        mLooper = mWorkerThread.getLooper();

        mMainThread = new HandlerThread("TestHandlerThread");

        mMainThread.start();

        mMainLooper = mMainThread.getLooper();

        mWifiTracker = new WifiTracker(mContext, mWifiListener, mLooper, true, true, true,

                mWifiManager, mMainLooper);

        mWifiTracker.mScanner = mWifiTracker.new Scanner();

        Mockito.when(mWifiManager.isWifiEnabled()).thenReturn(true);

    }

    @Override

    protected void tearDown() throws Exception {

        StringWriter sw = new StringWriter();

        PrintWriter pw = new PrintWriter(sw);

        mWifiTracker.dump(pw);

        pw.flush();

        Log.d(TAG, sw.toString());

        super.tearDown();

    }

    public void testAccessPointsCallback() {

        sendScanResultsAndProcess(false);

        Mockito.verify(mWifiListener, Mockito.atLeastOnce()).onAccessPointsChanged();

    }

    public void testConnectedCallback() {

        sendConnected();

        waitForThreads();

        Mockito.verify(mWifiListener, Mockito.atLeastOnce()).onConnectedChanged();

        assertEquals(true, mWifiTracker.isConnected());

    }

    public void testWifiStateCallback() {

        final int TEST_WIFI_STATE = WifiManager.WIFI_STATE_ENABLED;

        Intent i = new Intent(WifiManager.WIFI_STATE_CHANGED_ACTION);

        i.putExtra(WifiManager.EXTRA_WIFI_STATE, TEST_WIFI_STATE);

        mWifiTracker.mReceiver.onReceive(mContext, i);

        waitForThreads();

        ArgumentCaptor<Integer> wifiState = ArgumentCaptor.forClass(Integer.class);

        Mockito.verify(mWifiListener, Mockito.atLeastOnce())

                .onWifiStateChanged(wifiState.capture());

        assertEquals(TEST_WIFI_STATE, (int) wifiState.getValue());

    }

    public void testScanner() {

        // TODO: Figure out how to verify more of the Scanner functionality.

        // Make scans be successful.

        Mockito.when(mWifiManager.startScan()).thenReturn(true);

        mWifiTracker.mScanner.handleMessage(mWifiTracker.mScanner.obtainMessage(Scanner.MSG_SCAN));

        Mockito.verify(mWifiManager, Mockito.atLeastOnce()).startScan();

    }

    public void testNetworkSorting() {

        List<WifiConfiguration> wifiConfigs = new ArrayList<WifiConfiguration>();

        List<ScanResult> scanResults = new ArrayList<ScanResult>();

        String[] expectedSsids = generateTestNetworks(wifiConfigs, scanResults, true);

        // Tell WifiTracker we are connected now.

        sendConnected();

        // Send all of the configs and scan results to the tracker.

        Mockito.when(mWifiManager.getConfiguredNetworks()).thenReturn(wifiConfigs);

        Mockito.when(mWifiManager.getScanResults()).thenReturn(scanResults);

        sendScanResultsAndProcess(false);

        List<AccessPoint> accessPoints = mWifiTracker.getAccessPoints();

        assertEquals("Expected number of results", NUM_NETWORKS, accessPoints.size());

        for (int i = 0; i < NUM_NETWORKS; i++) {

            assertEquals("Verifying slot " + i, expectedSsids[i], accessPoints.get(i).getSsid());

        }

    }

    public void testSavedOnly() {

        mWifiTracker = new WifiTracker(mContext, mWifiListener, mLooper, true, false, true,

                mWifiManager, mMainLooper);

        mWifiTracker.mScanner = mWifiTracker.new Scanner();

        List<WifiConfiguration> wifiConfigs = new ArrayList<WifiConfiguration>();

        List<ScanResult> scanResults = new ArrayList<ScanResult>();

        generateTestNetworks(wifiConfigs, scanResults, true);

        // Tell WifiTracker we are connected now.

        sendConnected();

        // Send all of the configs and scan results to the tracker.

        Mockito.when(mWifiManager.getConfiguredNetworks()).thenReturn(wifiConfigs);

        Mockito.when(mWifiManager.getScanResults()).thenReturn(scanResults);

        sendScanResultsAndProcess(false);

        List<AccessPoint> accessPoints = mWifiTracker.getAccessPoints();

        // Only expect the first two to come back in the results.

        assertEquals("Expected number of results", 2, accessPoints.size());

        assertEquals(TEST_SSIDS[1], accessPoints.get(0).getSsid());

        assertEquals(TEST_SSIDS[0], accessPoints.get(1).getSsid());

    }

    /**

     * This tests the case where Settings runs this on a non-looper thread for indexing.

     */

    public void testSavedOnlyNoLooper() {

        mWifiTracker = new WifiTracker(mContext, mWifiListener, mLooper, true, false, true,

                mWifiManager,  null);

        mWifiTracker.mScanner = mWifiTracker.new Scanner();

        List<WifiConfiguration> wifiConfigs = new ArrayList<WifiConfiguration>();

        List<ScanResult> scanResults = new ArrayList<ScanResult>();

        generateTestNetworks(wifiConfigs, scanResults, true);

        // Send all of the configs and scan results to the tracker.

        Mockito.when(mWifiManager.getConfiguredNetworks()).thenReturn(wifiConfigs);

        Mockito.when(mWifiManager.getScanResults()).thenReturn(scanResults);

        mWifiTracker.forceUpdate();

        List<AccessPoint> accessPoints = mWifiTracker.getAccessPoints();

        // Only expect the first two to come back in the results.

        assertEquals("Expected number of results", 2, accessPoints.size());

        assertEquals(TEST_SSIDS[1], accessPoints.get(0).getSsid());

        assertEquals(TEST_SSIDS[0], accessPoints.get(1).getSsid());

    }

    public void testAvailableOnly() {

        mWifiTracker = new WifiTracker(mContext, mWifiListener, mLooper, false, true, true,

                mWifiManager, mMainLooper);

        mWifiTracker.mScanner = mWifiTracker.new Scanner();

        List<WifiConfiguration> wifiConfigs = new ArrayList<WifiConfiguration>();

        List<ScanResult> scanResults = new ArrayList<ScanResult>();

        String[] expectedSsids = generateTestNetworks(wifiConfigs, scanResults, true);

        // Tell WifiTracker we are connected now.

        sendConnected();

        // Send all of the configs and scan results to the tracker.

        Mockito.when(mWifiManager.getConfiguredNetworks()).thenReturn(wifiConfigs);

        Mockito.when(mWifiManager.getScanResults()).thenReturn(scanResults);

        sendScanResultsAndProcess(false);

        // Expect the last one (sorted order) to be left off since its only saved.

        List<AccessPoint> accessPoints = mWifiTracker.getAccessPoints();

        assertEquals("Expected number of results", NUM_NETWORKS - 1, accessPoints.size());

        for (int i = 0; i < NUM_NETWORKS - 1; i++) {

            assertEquals("Verifying slot " + i, expectedSsids[i], accessPoints.get(i).getSsid());

        }

    }

    public void testNonEphemeralConnected() {

        mWifiTracker = new WifiTracker(mContext, mWifiListener, mLooper, false, true, true,

                mWifiManager, mMainLooper);

        mWifiTracker.mScanner = mWifiTracker.new Scanner();

        List<WifiConfiguration> wifiConfigs = new ArrayList<WifiConfiguration>();

        List<ScanResult> scanResults = new ArrayList<ScanResult>();

        generateTestNetworks(wifiConfigs, scanResults, false);

        // Tell WifiTracker we are connected now.

        sendConnected();

        // Send all of the configs and scan results to the tracker.

        Mockito.when(mWifiManager.getConfiguredNetworks()).thenReturn(wifiConfigs);

        Mockito.when(mWifiManager.getScanResults()).thenReturn(scanResults);

        // Do this twice to catch a bug that was happening in the caching, making things ephemeral.

        sendScanResultsAndProcess(true);

        List<AccessPoint> accessPoints = mWifiTracker.getAccessPoints();

        assertEquals("Expected number of results", NUM_NETWORKS - 1, accessPoints.size());

        assertFalse("Connection is not ephemeral", accessPoints.get(0).isEphemeral());

        assertTrue("Connected to wifi", accessPoints.get(0).isActive());

    }

    public void testEnableResumeScanning() {

        mWifiTracker.mScanner = null;

        Intent i = new Intent(WifiManager.WIFI_STATE_CHANGED_ACTION);

        // Make sure disable/enable cycle works with no scanner (no crashing).

        i.putExtra(WifiManager.EXTRA_WIFI_STATE, WifiManager.WIFI_STATE_DISABLED);

        mWifiTracker.mReceiver.onReceive(mContext, i);

        i.putExtra(WifiManager.EXTRA_WIFI_STATE, WifiManager.WIFI_STATE_ENABLED);

        mWifiTracker.mReceiver.onReceive(mContext, i);

        Mockito.when(mWifiManager.isWifiEnabled()).thenReturn(false);

        i.putExtra(WifiManager.EXTRA_WIFI_STATE, WifiManager.WIFI_STATE_DISABLED);

        mWifiTracker.mReceiver.onReceive(mContext, i);

        // Now enable scanning while wifi is off, it shouldn't start.

        mWifiTracker.resumeScanning();

        assertFalse(mWifiTracker.mScanner.isScanning());

        // Turn on wifi and make sure scanning starts.

        i.putExtra(WifiManager.EXTRA_WIFI_STATE, WifiManager.WIFI_STATE_ENABLED);

        mWifiTracker.mReceiver.onReceive(mContext, i);

        assertTrue(mWifiTracker.mScanner.isScanning());

    }

    private String[] generateTestNetworks(List<WifiConfiguration> wifiConfigs,

            List<ScanResult> scanResults, boolean connectedIsEphemeral) {

        String[] expectedSsids = new String[NUM_NETWORKS];

        // First is just saved;

        addConfig(wifiConfigs, TEST_SSIDS[0]);

        // This should come last since its not available.

        expectedSsids[4] = TEST_SSIDS[0];

        // Second is saved and available.

        addConfig(wifiConfigs, TEST_SSIDS[1]);

        addResult(scanResults, TEST_SSIDS[1], 0);

        // This one is going to have a couple extra results, to verify de-duplication.

        addResult(scanResults, TEST_SSIDS[1], 2);

        addResult(scanResults, TEST_SSIDS[1], 1);

        // This should come second since it is available and saved but not connected.

        expectedSsids[1] = TEST_SSIDS[1];

        // Third is just available, but higher rssi.

        addResult(scanResults, TEST_SSIDS[2], 3);

        // This comes after the next one since it has a lower rssi.

        expectedSsids[3] = TEST_SSIDS[2];

        // Fourth also just available but with even higher rssi.

        addResult(scanResults, TEST_SSIDS[3], 4);

        // This is the highest rssi but not saved so it should be after the saved+availables.

        expectedSsids[2] = TEST_SSIDS[3];

        // Last is going to be connected.

        int netId = WifiConfiguration.INVALID_NETWORK_ID;

        if (!connectedIsEphemeral) {

            netId = addConfig(wifiConfigs, TEST_SSIDS[4]);

        }

        addResult(scanResults, TEST_SSIDS[4], 2);

        // Setup wifi connection to be this one.

        WifiInfo wifiInfo = Mockito.mock(WifiInfo.class);

        Mockito.when(wifiInfo.getSSID()).thenReturn(TEST_SSIDS[4]);

        Mockito.when(wifiInfo.getNetworkId()).thenReturn(netId);

        Mockito.when(mWifiManager.getConnectionInfo()).thenReturn(wifiInfo);

        // This should come first since it is connected.

        expectedSsids[0] = TEST_SSIDS[4];

        return expectedSsids;

    }

    private void addResult(List<ScanResult> results, String ssid, int level) {

        results.add(new ScanResult(WifiSsid.createFromAsciiEncoded(ssid),

                ssid, ssid, levelToRssi(level), AccessPoint.LOWER_FREQ_24GHZ, 0));

    }

    public static int levelToRssi(int level) {

        // Reverse level to rssi calculation based off from WifiManager.calculateSignalLevel.

        final int MAX_RSSI = -55;

        final int MIN_RSSI = -100;

        final int NUM_LEVELS = 4;

        return level * (MAX_RSSI - MIN_RSSI) / (NUM_LEVELS - 1) + MIN_RSSI;

    }

    private int addConfig(List<WifiConfiguration> configs, String ssid) {

        WifiConfiguration config = new WifiConfiguration();

        config.networkId = configs.size();

        config.SSID = '"' + ssid + '"';

        configs.add(config);

        return config.networkId;

    }

    private void sendConnected() {

        NetworkInfo networkInfo = Mockito.mock(NetworkInfo.class);

        Mockito.when(networkInfo.isConnected()).thenReturn(true);

        Mockito.when(networkInfo.getState()).thenReturn(State.CONNECTED);

        Intent intent = new Intent(WifiManager.NETWORK_STATE_CHANGED_ACTION);

        intent.putExtra(WifiManager.EXTRA_NETWORK_INFO, networkInfo);

        mWifiTracker.mReceiver.onReceive(mContext, intent);

    }

    private void sendScanResultsAndProcess(boolean sendTwice) {

        Intent i = new Intent(WifiManager.SCAN_RESULTS_AVAILABLE_ACTION);

        mWifiTracker.mReceiver.onReceive(mContext, i);

        if (sendTwice) {

            mWifiTracker.mReceiver.onReceive(mContext, i);

        }

        waitForThreads();

    }

    private void waitForThreads() {

        // Run all processing.

        mWorkerThread.quitSafely();

        try {

            mWorkerThread.join();

        } catch (InterruptedException e) {

        }

        // Send all callbacks.

        mMainThread.quitSafely();

        try {

            mMainThread.join();

        } catch (InterruptedException e) {

        }

    }

}