DO NOT MERGE: Allow Carriers to specify Wifi Networks.

Added support for Carrier networks. Added functionality to read
Carrier networks from Carrier Config.

Bug: 31003437
Test: Added new tests, regression tests passed (frameworks-wifi).
Change-Id: I9c3c03e2ab4a459898bec125f9dea8f96977e04f

3 files changed, 296 insertions, 132 deletions

diff --git a/service/java/com/android/server/wifi/WifiConfigManager.java b/service/java/com/android/server/wifi/WifiConfigManager.java
index 8e990ce08..84c87d96b 100644
--- a/service/java/com/android/server/wifi/WifiConfigManager.java
+++ b/service/java/com/android/server/wifi/WifiConfigManager.java
@@ -3191,6 +3191,35 @@ public class WifiConfigManager {
     }
 
     /**
+     * Saves the network and set the candidate.
+     * @param config WifiConfiguration to save.
+     * @param scanResult ScanResult to be used as the network selection candidate.
+     * @return WifiConfiguration that was saved and with the status updated.
+     */
+    public WifiConfiguration saveNetworkAndSetCandidate(WifiConfiguration config,
+                                                        ScanResult scanResult) {
+        // Mark this config as ephemeral so it isn't persisted.
+        config.ephemeral = true;
+        saveNetwork(config, WifiConfiguration.UNKNOWN_UID);
+
+        config.getNetworkSelectionStatus().setCandidate(scanResult);
+        return config;
+    }
+
+
+    /**
+     * Get the Scan Result candidate.
+     * @param config WifiConfiguration to get status for.
+     * @return scanResult which is the selection candidate.
+     */
+    public ScanResult getScanResultCandidate(WifiConfiguration config) {
+        if (config == null) {
+            return null;
+        }
+        return  config.getNetworkSelectionStatus().getCandidate();
+    }
+
+    /**
      * Checks if uid has access to modify config.
      */
     boolean canModifyNetwork(int uid, WifiConfiguration config, boolean onlyAnnotate) {
diff --git a/service/java/com/android/server/wifi/WifiQualifiedNetworkSelector.java b/service/java/com/android/server/wifi/WifiQualifiedNetworkSelector.java
index a612cbba1..33ce3cef4 100644
--- a/service/java/com/android/server/wifi/WifiQualifiedNetworkSelector.java
+++ b/service/java/com/android/server/wifi/WifiQualifiedNetworkSelector.java
@@ -26,6 +26,7 @@ import android.net.NetworkScoreManager;
 import android.net.WifiKey;
 import android.net.wifi.ScanResult;
 import android.net.wifi.WifiConfiguration;
+import android.net.wifi.WifiEnterpriseConfig;
 import android.net.wifi.WifiInfo;
 import android.net.wifi.WifiManager;
 import android.os.PersistableBundle;
@@ -78,6 +79,10 @@ public class WifiQualifiedNetworkSelector {
     //usable only when current state is connected state   default 10 s
     private static final int MINIMUM_QUALIFIED_NETWORK_SELECTION_INTERVAL = 10 * 1000;
 
+    private static final int CARRIER_SSID = 0;
+    private static final int CARRIER_KEY = 1;
+    private static final int CARRIER_EAP_METHOD = 2;
+
     //if current network is on 2.4GHz band and has a RSSI over this, need not new network selection
     public static final int QUALIFIED_RSSI_24G_BAND = -73;
     //if current network is on 5GHz band and has a RSSI over this, need not new network selection
@@ -118,7 +123,7 @@ public class WifiQualifiedNetworkSelector {
     private Map<String, BssidBlacklistStatus> mBssidBlacklist =
             new HashMap<String, BssidBlacklistStatus>();
     private List<WifiConfiguration> mCarrierConfiguredNetworks = new ArrayList<WifiConfiguration>();
-    private CarrierConfigManager mCarrierConfigManager;
+    private Context mContext;
 
     /**
      * class save the blacklist status of a given BSSID
@@ -136,6 +141,11 @@ public class WifiQualifiedNetworkSelector {
         }
     }
 
+    @VisibleForTesting
+    public void setCarrierConfiguredNetworks(List<WifiConfiguration> carrierConfiguredNetworks) {
+        mCarrierConfiguredNetworks = carrierConfiguredNetworks;
+    }
+
     private void localLoge(String log) {
         mLocalLog.log(log);
     }
@@ -176,6 +186,7 @@ public class WifiQualifiedNetworkSelector {
         mWifiConfigManager = configureStore;
         mWifiInfo = wifiInfo;
         mClock = clock;
+        mContext = context;
         mScoreManager =
                 (NetworkScoreManager) context.getSystemService(Context.NETWORK_SCORE_SERVICE);
         if (mScoreManager != null) {
@@ -202,52 +213,70 @@ public class WifiQualifiedNetworkSelector {
         mNoIntnetPenalty = (mWifiConfigManager.mThresholdSaturatedRssi24.get() + mRssiScoreOffset)
                 * mRssiScoreSlope + mWifiConfigManager.mBandAward5Ghz.get()
                 + mWifiConfigManager.mCurrentNetworkBoost.get() + mSameBssidAward + mSecurityAward;
-        mCarrierConfigManager = (CarrierConfigManager)
-                context.getSystemService(Context.CARRIER_CONFIG_SERVICE);
-
-        final BroadcastReceiver mBroadcastReceiver = new BroadcastReceiver() {
-            @Override
-            public void onReceive(Context context, Intent intent) {
-                localLog("mBroadcastReceiver: onReceive " + intent.getAction());
-                PersistableBundle b = mCarrierConfigManager.getConfig();
-                String[] mWifiArray =
-                        b.getStringArray(CarrierConfigManager.KEY_CARRIER_WIFI_STRING_ARRAY);
-                WifiConfiguration wifiConfig;
-                if (mWifiArray == null) {
-                    return;
-                }
 
-                for (String config : mWifiArray) {
-                    String[] wc = config.split("\\|");
-                    wifiConfig = new WifiConfiguration();
-                    try {
-                        byte[] decodedBytes = Base64.decode(wc[0], Base64.DEFAULT);
-                        String ssid = new String(decodedBytes);
-                        wifiConfig.SSID = "\"" + ssid  + "\"";
-                    } catch (IllegalArgumentException ex) {
-                        localLog("mBroadcaseReceiver: Could not decode base64 string");
-                        continue;
-                    }
-                    try {
-                        int s = Integer.parseInt(wc[1]);
-                        wifiConfig.allowedKeyManagement.set(s);
-                    } catch (NumberFormatException e) {
-                        localLog("mBroadcastReceiver: not an integer" + wc[1]);
-                    }
-                    mCarrierConfiguredNetworks.add(wifiConfig);
-                    localLog("mBroadcastReceiver: onReceive networks:" + wifiConfig.SSID);
-                }
-            }
-        };
         context.registerReceiver(mBroadcastReceiver, new IntentFilter(
                 CarrierConfigManager.ACTION_CARRIER_CONFIG_CHANGED));
     }
 
     @VisibleForTesting
-    public void setCarrierConfiguredNetworks(List<WifiConfiguration> carrierConfiguredNetworks) {
-        mCarrierConfiguredNetworks = carrierConfiguredNetworks;
+    public List<WifiConfiguration> parseCarrierSuppliedWifiInfo(String[] wifiArray) {
+        List<WifiConfiguration> carrierConfiguredNetworks = new ArrayList<WifiConfiguration>();
+        for (String config : wifiArray) {
+            String[] wc = config.split("\\|");
+            if (wc.length != 3) {
+                continue;
+            }
+            WifiConfiguration wifiConfig = new WifiConfiguration();
+            try {
+                byte[] decodedBytes = Base64.decode(wc[CARRIER_SSID], Base64.DEFAULT);
+                String ssid = new String(decodedBytes);
+                wifiConfig.SSID = "\"" + ssid + "\"";
+            } catch (IllegalArgumentException ex) {
+                localLog("mBroadcaseReceiver: Could not decode base64 string");
+                continue;
+            }
+            try {
+                int key = Integer.parseInt(wc[CARRIER_KEY]);
+                wifiConfig.allowedKeyManagement.set(key);
+                int eapType = Integer.parseInt(wc[CARRIER_EAP_METHOD]);
+                wifiConfig.enterpriseConfig = new WifiEnterpriseConfig();
+                wifiConfig.enterpriseConfig.setEapMethod(eapType);
+            } catch (NumberFormatException e) {
+                localLog("mBroadcastReceiver: not an integer:" + wc[CARRIER_KEY] + "," +
+                        wc[CARRIER_EAP_METHOD]);
+                continue;
+            } catch (IllegalArgumentException e) {
+                localLog("mBroadcastReceiver: invalid config" + wc[CARRIER_KEY] + "," +
+                        wc[CARRIER_EAP_METHOD]);
+            }
+            carrierConfiguredNetworks.add(wifiConfig);
+            localLog("mBroadcastReceiver: carrier config:" + wifiConfig.SSID);
+        }
+        return carrierConfiguredNetworks;
     }
 
+    final BroadcastReceiver mBroadcastReceiver = new BroadcastReceiver() {
+        @Override
+        public void onReceive(Context context, Intent intent) {
+            localLog("mBroadcastReceiver: onReceive " + intent.getAction());
+            String[] wifiArray = null;
+            CarrierConfigManager carrierConfigManager = (CarrierConfigManager)
+                    mContext.getSystemService(Context.CARRIER_CONFIG_SERVICE);
+            if (carrierConfigManager != null) {
+                PersistableBundle b = carrierConfigManager.getConfig();
+                if (b != null) {
+                    wifiArray = b.getStringArray(
+                            CarrierConfigManager.KEY_CARRIER_WIFI_STRING_ARRAY);
+                }
+            }
+
+            if (wifiArray == null) {
+                return;
+            }
+            mCarrierConfiguredNetworks = parseCarrierSuppliedWifiInfo(wifiArray);
+        }
+    };
+
     void enableVerboseLogging(int verbose) {
         mDbg = verbose > 0 || FORCE_DEBUG;
     }
@@ -638,13 +667,8 @@ public class WifiQualifiedNetworkSelector {
     }
 
     private boolean isCarrierNetwork(ScanResult scanResult) {
-        String ssid = "\"" + scanResult.SSID + "\"";
-        for (WifiConfiguration config : mCarrierConfiguredNetworks) {
-            if (config.SSID.equals(ssid)) {
-                return true;
-            }
-        }
-        return false;
+        return (getMatchingConfigForEAPNetworks(scanResult,
+                mCarrierConfiguredNetworks) != null ? true : false);
     }
 
     /**
@@ -800,24 +824,25 @@ public class WifiQualifiedNetworkSelector {
             // Evaluate the potentially ephemeral network as a possible candidate if untrusted
             // connections are allowed and we have an external score for the scan result.
             if (potentiallyEphemeral) {
-                localLog("Network is a ephemeral network...");
-                if (isUntrustedConnectionsAllowed) {
-                    Integer netScore = getNetworkScore(scanResult, false);
-                    if (netScore == null) {
-                        localLog("Checking the carrierScoreEvaluator for candidates...");
-                        // Evaluate the carrier network as a possible candidate.
-                        if (!mCarrierConfiguredNetworks.isEmpty() && isCarrierNetwork(scanResult)) {
-                            carrierScoreEvaluator.evalCarrierCandidate(scanResult,
-                                    getCarrierScore(scanResult, mCurrentConnectedNetwork,
-                                            (mCurrentBssid == null ? false :
-                                                    mCurrentBssid.equals(scanResult.BSSID))));
+                if (!mWifiConfigManager.wasEphemeralNetworkDeleted(
+                        ScanDetailUtil.createQuotedSSID(scanResult.SSID))) {
+                    if (isUntrustedConnectionsAllowed) {
+                        Integer netScore = getNetworkScore(scanResult, false);
+                        if (netScore != null) {
+                            externalScoreEvaluator.evalUntrustedCandidate(netScore, scanResult);
+                            // scanDetail is for available ephemeral network
+                            filteredScanDetails.add(Pair.create(scanDetail,
+                                    potentialEphemeralCandidate));
                         }
-
-                    }
-                    else if (!mWifiConfigManager.wasEphemeralNetworkDeleted(
-                                ScanDetailUtil.createQuotedSSID(scanResult.SSID))) {
-                        externalScoreEvaluator.evalUntrustedCandidate(netScore, scanResult);
-                        // scanDetail is for available ephemeral network
+                        // Evaluate the carrier network as a possible candidate.
+                        // todo need to add flag isCarrierConnectionsAllowed, config in settings.
+                    } else if (!mCarrierConfiguredNetworks.isEmpty() &&
+                            isCarrierNetwork(scanResult)) {
+                        localLog("Checking the carrierScoreEvaluator for candidates...");
+                        carrierScoreEvaluator.evalCarrierCandidate(scanResult,
+                                getCarrierScore(scanResult, mCurrentConnectedNetwork,
+                                        (mCurrentBssid == null ? false :
+                                                mCurrentBssid.equals(scanResult.BSSID))));
                         filteredScanDetails.add(Pair.create(scanDetail,
                                 potentialEphemeralCandidate));
                     }
@@ -953,7 +978,8 @@ public class WifiQualifiedNetworkSelector {
             networkCandidate = getCarrierScoreCandidate(carrierScoreEvaluator);
             localLog("Carrier candidate::" + networkCandidate);
             if (networkCandidate != null) {
-                scanResultCandidate = networkCandidate.getNetworkSelectionStatus().getCandidate();
+                scanResultCandidate =
+                        mWifiConfigManager.getScanResultCandidate(networkCandidate);
             }
         }
 
@@ -1046,25 +1072,22 @@ public class WifiQualifiedNetworkSelector {
      */
     @Nullable
     WifiConfiguration getCarrierScoreCandidate(CarrierScoreEvaluator scoreEvaluator) {
-        WifiConfiguration networkCandidate = null;
 
-        ScanResult untrustedScanResultCandidate = scoreEvaluator.getScanResultCandidate();
-        if (untrustedScanResultCandidate == null) {
+        ScanResult untrustedCarrierScanResult = scoreEvaluator.getScanResultCandidate();
+        if (untrustedCarrierScanResult == null) {
             return null;
         }
-        WifiConfiguration unTrustedNetworkCandidate =
-                mWifiConfigManager.wifiConfigurationFromScanResult(
-                                untrustedScanResultCandidate);
-        // Mark this config as ephemeral so it isn't persisted.
-        unTrustedNetworkCandidate.ephemeral = true;
-        mWifiConfigManager.saveNetwork(unTrustedNetworkCandidate, WifiConfiguration.UNKNOWN_UID);
-        localLog(String.format("new carrier candidate %s network ID:%d, ",
-                toScanId(untrustedScanResultCandidate), unTrustedNetworkCandidate.networkId));
-
-        unTrustedNetworkCandidate.getNetworkSelectionStatus()
-                .setCandidate(untrustedScanResultCandidate);
-        networkCandidate = unTrustedNetworkCandidate;
-        return networkCandidate;
+
+        WifiConfiguration untrustedCandidateConfig = getMatchingConfigForEAPNetworks(
+                untrustedCarrierScanResult, mCarrierConfiguredNetworks);
+
+        if (untrustedCandidateConfig == null) {
+            return null;
+        }
+
+        mWifiConfigManager.saveNetworkAndSetCandidate(
+                untrustedCandidateConfig, untrustedCarrierScanResult);
+        return untrustedCandidateConfig;
     }
 
     /**
@@ -1217,7 +1240,6 @@ public class WifiQualifiedNetworkSelector {
     static class CarrierScoreEvaluator {
         // Always set to the best known candidate
         private int mHighScore = WifiNetworkScoreCache.INVALID_NETWORK_SCORE;
-        private WifiConfiguration mSavedConfig;
         private ScanResult mScanResultCandidate;
         private final LocalLog mLocalLog;
         private final boolean mDbg;
@@ -1245,14 +1267,32 @@ public class WifiQualifiedNetworkSelector {
             return mScanResultCandidate;
         }
 
-        WifiConfiguration getSavedConfig() {
-            return mSavedConfig;
-        }
-
         private void localLog(String log) {
             if (mDbg) {
                 mLocalLog.log(log);
             }
         }
     }
+
+    private WifiConfiguration getMatchingConfigForEAPNetworks(
+            ScanResult scanResult, List<WifiConfiguration> candidateConfigs) {
+        if (scanResult == null || candidateConfigs == null) {
+            return null;
+        }
+        // TODO currently we only support EAP. We'll add to this in OC.
+        if (!scanResult.capabilities.contains("EAP")) {
+            return null;
+        }
+        String ssid = "\"" + scanResult.SSID + "\"";
+        for (WifiConfiguration config : candidateConfigs) {
+            if (config.SSID.equals(ssid)) {
+                // TODO currently we only support EAP. We'll add to this in OC.
+                if (config.allowedKeyManagement.get(WifiConfiguration.KeyMgmt.WPA_EAP) ||
+                        config.allowedKeyManagement.get(WifiConfiguration.KeyMgmt.IEEE8021X)) {
+                    return config;
+                }
+            }
+        }
+        return null;
+    }
 }
diff --git a/tests/wifitests/src/com/android/server/wifi/WifiQualifiedNetworkSelectorTest.java b/tests/wifitests/src/com/android/server/wifi/WifiQualifiedNetworkSelectorTest.java
index 957e8c24c..3c2d31fdf 100644
--- a/tests/wifitests/src/com/android/server/wifi/WifiQualifiedNetworkSelectorTest.java
+++ b/tests/wifitests/src/com/android/server/wifi/WifiQualifiedNetworkSelectorTest.java
@@ -23,9 +23,12 @@ import static com.android.server.wifi.WifiConfigurationTestUtil.generateWifiConf
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import org.mockito.AdditionalAnswers;
 import static org.mockito.Matchers.any;
 import static org.mockito.Matchers.anyBoolean;
 import static org.mockito.Matchers.anyInt;
+import static org.mockito.Matchers.anyObject;
 import static org.mockito.Matchers.eq;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.validateMockitoUsage;
@@ -41,8 +44,10 @@ import android.net.wifi.WifiEnterpriseConfig;
 import android.net.wifi.WifiInfo;
 import android.net.wifi.WifiSsid;
 import android.os.SystemClock;
+import android.os.UserManager;
 import android.test.suitebuilder.annotation.SmallTest;
 import android.util.LocalLog;
+import com.android.server.wifi.NetworkUpdateResult;
 
 import com.android.internal.R;
 import com.android.server.wifi.MockAnswerUtil.AnswerWithArguments;
@@ -82,19 +87,27 @@ public class WifiQualifiedNetworkSelectorTest {
         when(mClock.elapsedRealtime()).thenReturn(SystemClock.elapsedRealtime());
 
         //setup Carrier Networks
+        int eapType = 4;
+
         WifiConfiguration wifiConfig = new WifiConfiguration();
         wifiConfig.SSID = "\"TEST1\"";
         wifiConfig.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_EAP);
+        wifiConfig.enterpriseConfig = new WifiEnterpriseConfig();
+        wifiConfig.enterpriseConfig.setEapMethod(eapType);
         mCarrierConfiguredNetworks.add(wifiConfig);
 
         WifiConfiguration wifiConfig1 = new WifiConfiguration();
         wifiConfig1.SSID = "\"TEST2\"";
         wifiConfig1.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_EAP);
+        wifiConfig1.enterpriseConfig = new WifiEnterpriseConfig();
+        wifiConfig1.enterpriseConfig.setEapMethod(eapType);
         mCarrierConfiguredNetworks.add(wifiConfig1);
 
         WifiConfiguration wifiConfig2 = new WifiConfiguration();
         wifiConfig2.SSID = "\"TEST3\"";
         wifiConfig2.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_EAP);
+        wifiConfig2.enterpriseConfig = new WifiEnterpriseConfig();
+        wifiConfig2.enterpriseConfig.setEapMethod(eapType);
         mCarrierConfiguredNetworks.add(wifiConfig2);
         mWifiQualifiedNetworkSelector.setCarrierConfiguredNetworks(mCarrierConfiguredNetworks);
     }
@@ -2423,29 +2436,21 @@ public class WifiQualifiedNetworkSelectorTest {
         int[] security = {SECURITY_PSK, SECURITY_PSK};
 
         List<ScanDetail> scanDetails = getScanDetails(ssids, bssids, frequencies, caps, levels);
-
-        WifiConfiguration[] savedConfigs = generateWifiConfigurations(ssids, security);
-        prepareConfigStore(savedConfigs);
-
         ScanResult chosenScanResult = scanDetails.get(1).getScanResult();
-        WifiConfiguration unTrustedNetworkCandidate = mock(WifiConfiguration.class);
-        unTrustedNetworkCandidate.SSID = null;
-        unTrustedNetworkCandidate.networkId = WifiConfiguration.INVALID_NETWORK_ID;
-        when(mWifiConfigManager.updateSavedNetworkWithNewScanDetail(scanDetails.get(1),
-                false)).thenReturn(null);
-        when(mWifiConfigManager
-                .wifiConfigurationFromScanResult(scanDetails.get(1).getScanResult()))
-                .thenReturn(unTrustedNetworkCandidate);
-        WifiConfiguration.NetworkSelectionStatus selectionStatus =
-                mock(WifiConfiguration.NetworkSelectionStatus.class);
-        when(unTrustedNetworkCandidate.getNetworkSelectionStatus()).thenReturn(selectionStatus);
-        when(selectionStatus.getCandidate()).thenReturn(chosenScanResult);
+        when(mWifiConfigManager.updateSavedNetworkWithNewScanDetail(any(ScanDetail.class),
+                any(Boolean.class))).thenReturn(null);
+        when(mWifiConfigManager.saveNetworkAndSetCandidate(any(WifiConfiguration.class),
+                any(ScanResult.class))).then(AdditionalAnswers.returnsFirstArg());
+        when(mWifiConfigManager.getScanResultCandidate(
+                mCarrierConfiguredNetworks.get(1))).thenReturn(chosenScanResult);
 
         WifiConfiguration candidate = mWifiQualifiedNetworkSelector.selectQualifiedNetwork(false,
-                true, scanDetails, false, false, true, false);
-        assertSame(unTrustedNetworkCandidate, candidate);
+                false, scanDetails, false, false, true, false);
+
+        assertTrue(candidate.SSID.contains(chosenScanResult.SSID));
     }
 
+
     /**
      * Case #50 Choose 5G over 2G.
      */
@@ -2460,22 +2465,16 @@ public class WifiQualifiedNetworkSelectorTest {
 
         List<ScanDetail> scanDetails = getScanDetails(ssids, bssids, frequencies, caps, levels);
         ScanResult chosenScanResult = scanDetails.get(1).getScanResult();
-        WifiConfiguration unTrustedNetworkCandidate = mock(WifiConfiguration.class);
-        unTrustedNetworkCandidate.SSID = null;
-        unTrustedNetworkCandidate.networkId = WifiConfiguration.INVALID_NETWORK_ID;
-        when(mWifiConfigManager.updateSavedNetworkWithNewScanDetail(scanDetails.get(1),
-                false)).thenReturn(null);
-        when(mWifiConfigManager
-                .wifiConfigurationFromScanResult(scanDetails.get(1).getScanResult()))
-                .thenReturn(unTrustedNetworkCandidate);
-        WifiConfiguration.NetworkSelectionStatus selectionStatus =
-                mock(WifiConfiguration.NetworkSelectionStatus.class);
-        when(unTrustedNetworkCandidate.getNetworkSelectionStatus()).thenReturn(selectionStatus);
-        when(selectionStatus.getCandidate()).thenReturn(chosenScanResult);
+        when(mWifiConfigManager.updateSavedNetworkWithNewScanDetail(any(ScanDetail.class),
+                any(Boolean.class))).thenReturn(null);
+        when(mWifiConfigManager.saveNetworkAndSetCandidate(any(WifiConfiguration.class),
+                any(ScanResult.class))).then(AdditionalAnswers.returnsFirstArg());
+        when(mWifiConfigManager.getScanResultCandidate(
+                mCarrierConfiguredNetworks.get(1))).thenReturn(chosenScanResult);
 
         WifiConfiguration candidate = mWifiQualifiedNetworkSelector.selectQualifiedNetwork(false,
-                true, scanDetails, false, false, true, false);
-        assertSame(unTrustedNetworkCandidate, candidate);
+                false, scanDetails, false, false, true, false);
+        assertTrue(candidate.SSID.contains(chosenScanResult.SSID));
     }
 
     /**
@@ -2496,25 +2495,18 @@ public class WifiQualifiedNetworkSelectorTest {
         prepareConfigStore(savedConfigs);
 
         ScanResult chosenScanResult = scanDetails.get(0).getScanResult();
-        WifiConfiguration unTrustedNetworkCandidate = mock(WifiConfiguration.class);
-        unTrustedNetworkCandidate.SSID = null;
-        unTrustedNetworkCandidate.networkId = WifiConfiguration.INVALID_NETWORK_ID;
-
+        when(mWifiConfigManager.updateSavedNetworkWithNewScanDetail(any(ScanDetail.class),
+                any(Boolean.class))).thenReturn(null);
+        when(mWifiConfigManager.saveNetworkAndSetCandidate(any(WifiConfiguration.class),
+                any(ScanResult.class))).then(AdditionalAnswers.returnsFirstArg());
+        when(mWifiConfigManager.getScanResultCandidate(
+                mCarrierConfiguredNetworks.get(0))).thenReturn(chosenScanResult);
         when(mWifiInfo.getNetworkId()).thenReturn(0);
         when(mWifiInfo.getBSSID()).thenReturn(bssids[0]);
-        when(mWifiConfigManager.updateSavedNetworkWithNewScanDetail(scanDetails.get(0),
-                true)).thenReturn(null);
-        when(mWifiConfigManager
-                .wifiConfigurationFromScanResult(scanDetails.get(0).getScanResult()))
-                .thenReturn(unTrustedNetworkCandidate);
-        WifiConfiguration.NetworkSelectionStatus selectionStatus =
-                mock(WifiConfiguration.NetworkSelectionStatus.class);
-        when(unTrustedNetworkCandidate.getNetworkSelectionStatus()).thenReturn(selectionStatus);
-        when(selectionStatus.getCandidate()).thenReturn(chosenScanResult);
 
         WifiConfiguration candidate = mWifiQualifiedNetworkSelector.selectQualifiedNetwork(false,
-                true, scanDetails, false, true, false, false);
-        assertSame(unTrustedNetworkCandidate, candidate);
+                false, scanDetails, false, true, false, false);
+        assertTrue(candidate.SSID.contains(chosenScanResult.SSID));
     }
 
     /**
@@ -2539,4 +2531,107 @@ public class WifiQualifiedNetworkSelectorTest {
                 true, scanDetails, false, false, true, false);
         assertEquals("Expect no network selection", null, candidate);
     }
+
+    /**
+     * Case #53 Test condition where no Carrier networks are defined.
+     */
+    @Test
+    public void testParseCarrierInfoSuccess()  {
+        String[] wifiArray = new String[3];
+        wifiArray[0] = "V2lmaSBFeHRyYQ==|2|4";
+        wifiArray[1] = "R29vZ2xlLUE=|2|4";
+        wifiArray[2] = "R29vZ2xlLUd1ZXN0|2|4";
+
+        List<WifiConfiguration> configList =
+                mWifiQualifiedNetworkSelector.parseCarrierSuppliedWifiInfo(wifiArray);
+        assertEquals("Expect right number of etnries", configList.size(), 3);
+        assertEquals("Expect right network", configList.get(0).SSID, "\"Wifi Extra\"");
+        assertEquals("Expect right network", configList.get(1).SSID, "\"Google-A\"");
+        assertEquals("Expect right network", configList.get(2).SSID, "\"Google-Guest\"");
+        assertTrue("Expect right key",
+                configList.get(0).allowedKeyManagement.get(WifiConfiguration.KeyMgmt.WPA_EAP));
+        assertEquals("Expect right EAP method",
+                configList.get(0).enterpriseConfig.getEapMethod(), 4);
+    }
+
+    /**
+     * Case #54 Test condition where string has non-numerics.
+     */
+    @Test
+    public void testParseCarrierInfoBadEntries1()  {
+        String[] wifiArray = new String[3];
+        wifiArray[0] = "V2lmaSBFeHRyYQ==|2|4";
+        wifiArray[1] = "R29vZ2xlLUE=|2|A"; //Invalid entry. Non-numeric.
+        wifiArray[2] = "R29vZ2xlLUd1ZXN0|2|4";
+
+        List<WifiConfiguration> configList =
+                mWifiQualifiedNetworkSelector.parseCarrierSuppliedWifiInfo(wifiArray);
+        assertEquals("Expect right number of etnries", configList.size(), 2);
+        assertEquals("Expect right network", configList.get(0).SSID, "\"Wifi Extra\"");
+        assertEquals("Expect right network", configList.get(1).SSID, "\"Google-Guest\"");
+    }
+
+    /**
+     * Case #55 Test condition where the config does not have the right number of entries.
+     */
+    @Test
+    public void testParseCarrierInfoBadEntries2()  {
+        String[] wifiArray = new String[3];
+        wifiArray[0] = "V2lmaSBFeHRyYQ==|2"; //Invalid number of entries
+        wifiArray[1] = "R29vZ2xlLUE=|2|4";
+        wifiArray[2] = "R29vZ2xlLUd1ZXN0|2|4";
+
+        List<WifiConfiguration> configList =
+                mWifiQualifiedNetworkSelector.parseCarrierSuppliedWifiInfo(wifiArray);
+        assertEquals("Expect right network", configList.get(0).SSID, "\"Google-A\"");
+        assertEquals("Expect right network", configList.get(1).SSID, "\"Google-Guest\"");
+    }
+
+    /**
+     * Case #56 Test invalid base-64.
+     */
+    @Test
+    public void testParseCarrierInfoBadBase64()  {
+        String[] wifiArray = new String[3];
+        wifiArray[0] = "V2lmaSBFeHRyYQ==|2|4";
+        wifiArray[1] = "xyz==|2|4"; //Invalid base64
+        wifiArray[2] = "R29vZ2xlLUd1ZXN0|2|4";
+
+        List<WifiConfiguration> configList =
+                mWifiQualifiedNetworkSelector.parseCarrierSuppliedWifiInfo(wifiArray);
+        assertEquals("Expect right network", configList.get(0).SSID, "\"Wifi Extra\"");
+        assertEquals("Expect right network", configList.get(1).SSID, "\"Google-Guest\"");
+    }
+
+    /**
+     * Case #56 Test invalid eap-method
+     */
+    @Test
+    public void testParseCarrierInfoBadEapMethod()  {
+        String[] wifiArray = new String[3];
+        wifiArray[0] = "V2lmaSBFeHRyYQ==|2|4";
+        wifiArray[1] = "R29vZ2xlLUE=|2|4";
+        wifiArray[2] = "R29vZ2xlLUd1ZXN0|2|11"; //Invalid eap-method
+
+        List<WifiConfiguration> configList =
+                mWifiQualifiedNetworkSelector.parseCarrierSuppliedWifiInfo(wifiArray);
+        assertEquals("Expect right network", configList.get(0).SSID, "\"Wifi Extra\"");
+        assertEquals("Expect right network", configList.get(1).SSID, "\"Google-A\"");
+    }
+
+    /**
+     * Case #56 Test invalid key
+     */
+    @Test
+    public void testParseCarrierInfoBadKey()  {
+        String[] wifiArray = new String[3];
+        wifiArray[0] = "V2lmaSBFeHRyYQ==|2|4";
+        wifiArray[1] = "R29vZ2xlLUE=|9|4";  //Invalid key
+        wifiArray[2] = "R29vZ2xlLUd1ZXN0|2|4";
+
+        List<WifiConfiguration> configList =
+                mWifiQualifiedNetworkSelector.parseCarrierSuppliedWifiInfo(wifiArray);
+        assertEquals("Expect right network", configList.get(0).SSID, "\"Wifi Extra\"");
+        assertEquals("Expect right network", configList.get(2).SSID, "\"Google-Guest\"");
+    }
 }