Home | History | Annotate | Download | only in wifi 
      1 /*
      2  * Copyright (C) 2017 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 package com.android.settingslib.wifi;
     17 
     18 import static com.google.common.truth.Truth.assertThat;
     19 import static org.mockito.ArgumentMatchers.anyInt;
     20 import static org.mockito.Mockito.any;
     21 import static org.mockito.Mockito.doReturn;
     22 import static org.mockito.Mockito.when;
     23 
     24 import android.content.Context;
     25 import android.net.NetworkKey;
     26 import android.net.RssiCurve;
     27 import android.net.ScoredNetwork;
     28 import android.net.WifiKey;
     29 import android.net.wifi.ScanResult;
     30 import android.net.wifi.WifiConfiguration;
     31 import android.net.wifi.WifiNetworkScoreCache;
     32 import android.os.Bundle;
     33 import android.os.Parcelable;
     34 import android.os.SystemClock;
     35 import android.text.format.DateUtils;
     36 import android.util.ArraySet;
     37 
     38 import com.android.settingslib.R;
     39 import com.android.settingslib.SettingsLibRobolectricTestRunner;
     40 
     41 import org.junit.Before;
     42 import org.junit.Test;
     43 import org.junit.runner.RunWith;
     44 import org.mockito.Mock;
     45 import org.mockito.MockitoAnnotations;
     46 import org.robolectric.RuntimeEnvironment;
     47 
     48 import java.util.ArrayList;
     49 import java.util.Set;
     50 
     51 @RunWith(SettingsLibRobolectricTestRunner.class)
     52 public class WifiUtilsTest {
     53     private static final String TEST_SSID = "\"test_ssid\"";
     54     private static final String TEST_BSSID = "00:00:00:00:00:00";
     55     private static final long MAX_SCORE_CACHE_AGE_MILLIS =
     56             20 * DateUtils.MINUTE_IN_MILLIS;
     57 
     58     private Context mContext;
     59     @Mock
     60     private RssiCurve mockBadgeCurve;
     61     @Mock
     62     private WifiNetworkScoreCache mockWifiNetworkScoreCache;
     63     @Mock
     64     private AccessPoint mAccessPoint;
     65     @Mock
     66     WifiConfiguration mWifiConfig;
     67 
     68     @Before
     69     public void setUp() {
     70         MockitoAnnotations.initMocks(this);
     71         mContext = RuntimeEnvironment.application;
     72     }
     73 
     74     @Test
     75     public void testVerboseSummaryString_showsScanResultSpeedLabel() {
     76         WifiTracker.sVerboseLogging = true;
     77 
     78         Bundle bundle = new Bundle();
     79         ArrayList<ScanResult> scanResults = buildScanResultCache();
     80         bundle.putParcelableArray(AccessPoint.KEY_SCANRESULTS,
     81                                   scanResults.toArray(new Parcelable[scanResults.size()]));
     82         AccessPoint ap = new AccessPoint(mContext, bundle);
     83 
     84         when(mockWifiNetworkScoreCache.getScoredNetwork(any(ScanResult.class)))
     85                 .thenReturn(buildScoredNetworkWithGivenBadgeCurve(mockBadgeCurve));
     86         when(mockBadgeCurve.lookupScore(anyInt())).thenReturn((byte) AccessPoint.Speed.VERY_FAST);
     87 
     88         ap.update(mockWifiNetworkScoreCache, true /* scoringUiEnabled */,
     89                 MAX_SCORE_CACHE_AGE_MILLIS);
     90         String summary = WifiUtils.verboseScanResultSummary(ap, scanResults.get(0), null, 0);
     91 
     92         assertThat(summary.contains(mContext.getString(R.string.speed_label_very_fast))).isTrue();
     93     }
     94 
     95     @Test
     96     public void testGetVisibilityStatus_nullResultDoesNotCrash() {
     97         doReturn(null).when(mAccessPoint).getInfo();
     98         Set<ScanResult> set = new ArraySet<>();
     99         set.add(null);
    100         doReturn(set).when(mAccessPoint).getScanResults();
    101         WifiUtils.getVisibilityStatus(mAccessPoint);
    102     }
    103 
    104     @Test
    105     public void testGetMeteredLabel_returnsCorrectValues() {
    106         mWifiConfig.meteredHint = true;
    107         mWifiConfig.meteredOverride = WifiConfiguration.METERED_OVERRIDE_NONE;
    108         assertThat(WifiUtils.getMeteredLabel(mContext, mWifiConfig)).isEqualTo("Metered");
    109 
    110         mWifiConfig.meteredHint = false;
    111         mWifiConfig.meteredOverride = WifiConfiguration.METERED_OVERRIDE_METERED;
    112         assertThat(WifiUtils.getMeteredLabel(mContext, mWifiConfig)).isEqualTo("Metered");
    113 
    114         mWifiConfig.meteredHint = true;
    115         mWifiConfig.meteredOverride = WifiConfiguration.METERED_OVERRIDE_METERED;
    116         assertThat(WifiUtils.getMeteredLabel(mContext, mWifiConfig)).isEqualTo("Metered");
    117 
    118         mWifiConfig.meteredHint = false;
    119         mWifiConfig.meteredOverride = WifiConfiguration.METERED_OVERRIDE_NOT_METERED;
    120         assertThat(WifiUtils.getMeteredLabel(mContext, mWifiConfig)).isEqualTo("Unmetered");
    121 
    122         mWifiConfig.meteredHint = true;
    123         mWifiConfig.meteredOverride = WifiConfiguration.METERED_OVERRIDE_NOT_METERED;
    124         assertThat(WifiUtils.getMeteredLabel(mContext, mWifiConfig)).isEqualTo("Unmetered");
    125     }
    126 
    127     @Test
    128     public void testIsMeteredOverridden_returnsCorrectValues() {
    129         mWifiConfig.meteredHint = true;
    130         mWifiConfig.meteredOverride = WifiConfiguration.METERED_OVERRIDE_NONE;
    131         assertThat(WifiUtils.isMeteredOverridden(mWifiConfig)).isFalse();
    132 
    133         mWifiConfig.meteredHint = false;
    134         mWifiConfig.meteredOverride = WifiConfiguration.METERED_OVERRIDE_METERED;
    135         assertThat(WifiUtils.isMeteredOverridden(mWifiConfig)).isTrue();
    136 
    137         mWifiConfig.meteredHint = true;
    138         mWifiConfig.meteredOverride = WifiConfiguration.METERED_OVERRIDE_METERED;
    139         assertThat(WifiUtils.isMeteredOverridden(mWifiConfig)).isTrue();
    140 
    141         mWifiConfig.meteredHint = false;
    142         mWifiConfig.meteredOverride = WifiConfiguration.METERED_OVERRIDE_NOT_METERED;
    143         assertThat(WifiUtils.isMeteredOverridden(mWifiConfig)).isTrue();
    144 
    145         mWifiConfig.meteredHint = true;
    146         mWifiConfig.meteredOverride = WifiConfiguration.METERED_OVERRIDE_NOT_METERED;
    147         assertThat(WifiUtils.isMeteredOverridden(mWifiConfig)).isTrue();
    148     }
    149 
    150     private static ArrayList<ScanResult> buildScanResultCache() {
    151         ArrayList<ScanResult> scanResults = new ArrayList<>();
    152         for (int i = 0; i < 5; i++) {
    153             ScanResult scanResult = createScanResult(TEST_SSID, "bssid-" + i, i);
    154             scanResults.add(scanResult);
    155         }
    156         return scanResults;
    157     }
    158 
    159     private static ScanResult createScanResult(String ssid, String bssid, int rssi) {
    160         ScanResult scanResult = new ScanResult();
    161         scanResult.SSID = ssid;
    162         scanResult.level = rssi;
    163         scanResult.BSSID = bssid;
    164         scanResult.timestamp = SystemClock.elapsedRealtime() * 1000;
    165         scanResult.capabilities = "";
    166         return scanResult;
    167     }
    168 
    169     private ScoredNetwork buildScoredNetworkWithGivenBadgeCurve(RssiCurve badgeCurve) {
    170         Bundle attr1 = new Bundle();
    171         attr1.putParcelable(ScoredNetwork.ATTRIBUTES_KEY_BADGING_CURVE, badgeCurve);
    172         return new ScoredNetwork(
    173                 new NetworkKey(new WifiKey(TEST_SSID, TEST_BSSID)),
    174                 badgeCurve,
    175                 false /* meteredHint */,
    176                 attr1);
    177     }
    178 }
    179