diff --git a/src/com/android/ons/ONSNetworkScanCtlr.java b/src/com/android/ons/ONSNetworkScanCtlr.java
index 181a56c..57864c9 100644
--- a/src/com/android/ons/ONSNetworkScanCtlr.java
+++ b/src/com/android/ons/ONSNetworkScanCtlr.java
@@ -26,6 +26,8 @@
 import android.telephony.CarrierConfigManager;
 import android.telephony.CellInfo;
 import android.telephony.CellInfoLte;
+import android.telephony.CellInfoNr;
+import android.telephony.CellSignalStrengthNr;
 import android.telephony.NetworkScan;
 import android.telephony.NetworkScanRequest;
 import android.telephony.RadioAccessSpecifier;
@@ -37,6 +39,8 @@
 import com.android.telephony.Rlog;
 
 import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.stream.Collectors;
 import java.util.List;
 import java.util.Set;
 import java.util.concurrent.TimeUnit;
@@ -59,6 +63,23 @@
     private static final int MSG_SCAN_COMPLETE = 2;
     private static final int MSG_SCAN_ERROR = 3;
 
+    private Boolean mIs4gScanEnabled = null;
+
+    @VisibleForTesting
+    static final RadioAccessSpecifier DEFAULT_5G_RAS = new RadioAccessSpecifier(
+            AccessNetworkConstants.AccessNetworkType.NGRAN,
+            new int[] {
+                AccessNetworkConstants.NgranBands.BAND_48,
+                AccessNetworkConstants.NgranBands.BAND_71},
+            null);
+    @VisibleForTesting
+    static final RadioAccessSpecifier DEFAULT_4G_RAS = new RadioAccessSpecifier(
+        AccessNetworkConstants.AccessNetworkType.NGRAN,
+        new int[] {
+                AccessNetworkConstants.EutranBand.BAND_48,
+                AccessNetworkConstants.EutranBand.BAND_71},
+        null);
+
     /* scan object to keep track of current scan request */
     private NetworkScan mCurrentScan;
     private boolean mIsScanActive;
@@ -67,6 +88,7 @@
     private TelephonyManager mTelephonyManager;
     private CarrierConfigManager configManager;
     private int mRsrpEntryThreshold;
+    private int mSsRsrpEntryThreshold;
     @VisibleForTesting
     protected NetworkAvailableCallBack mNetworkAvailableCallBack;
     HandlerThread mThread;
@@ -119,12 +141,16 @@
         void onError(int error);
     }
 
-    private int getIntCarrierConfig(String key) {
-        PersistableBundle b = null;
+    private PersistableBundle getConfigBundle() {
         if (configManager != null) {
             // If an invalid subId is used, this bundle will contain default values.
-            b = configManager.getConfig();
+            return configManager.getConfig();
         }
+        return null;
+    }
+
+    private int getIntCarrierConfig(String key) {
+        PersistableBundle b = getConfigBundle();
         if (b != null) {
             return b.getInt(key);
         } else {
@@ -133,6 +159,16 @@
         }
     }
 
+    private boolean getBooleanCarrierConfig(String key) {
+        PersistableBundle b = getConfigBundle();
+        if (b != null) {
+            return b.getBoolean(key);
+        } else {
+            // Return static default defined in CarrierConfigManager.
+            return CarrierConfigManager.getDefaultConfig().getBoolean(key);
+        }
+    }
+
     /**
      * analyze scan results
      * @param results contains all available cells matching the scan request at current location.
@@ -143,10 +179,20 @@
           return;
         }
         List<CellInfo> filteredResults = new ArrayList<CellInfo>();
+        mIs4gScanEnabled = getIs4gScanEnabled();
         synchronized (mLock) {
             for (CellInfo cellInfo : results) {
                 if (mMccMncs.contains(getMccMnc(cellInfo))) {
-                    if (cellInfo instanceof CellInfoLte) {
+                    if (cellInfo instanceof CellInfoNr) {
+                        CellInfoNr nrCellInfo = (CellInfoNr) cellInfo;
+                        int ssRsrp = ((CellSignalStrengthNr) nrCellInfo.getCellSignalStrength())
+                                .getSsRsrp();
+                        logDebug("cell info ssRsrp: " + ssRsrp);
+                        if (ssRsrp >= mSsRsrpEntryThreshold) {
+                            filteredResults.add(cellInfo);
+                        }
+                    }
+                    if (mIs4gScanEnabled && cellInfo instanceof CellInfoLte) {
                         int rsrp = ((CellInfoLte) cellInfo).getCellSignalStrength().getRsrp();
                         logDebug("cell info rsrp: " + rsrp);
                         if (rsrp >= mRsrpEntryThreshold) {
@@ -229,27 +275,87 @@
         return null;
     }
 
-    private NetworkScanRequest createNetworkScanRequest(ArrayList<AvailableNetworkInfo> availableNetworks,
-            int periodicity) {
-        RadioAccessSpecifier[] ras = new RadioAccessSpecifier[1];
-        ArrayList<String> mccMncs = new ArrayList<String>();
-        Set<Integer> bandSet = new ArraySet<>();
+    private boolean getIs4gScanEnabled() {
+        // TODO: make this a null check
+        if (mIs4gScanEnabled != null) {
+            return mIs4gScanEnabled;
+        }
+        return getBooleanCarrierConfig(
+                CarrierConfigManager.KEY_ENABLE_4G_OPPORTUNISTIC_NETWORK_SCAN_BOOL);
+    }
 
-        /* by default add band 48 */
-        bandSet.add(AccessNetworkConstants.EutranBand.BAND_48);
+    @VisibleForTesting
+    void setIs4gScanEnabled(boolean enabled) {
+        mIs4gScanEnabled = enabled;
+    }
+
+    @VisibleForTesting
+    NetworkScanRequest createNetworkScanRequest(ArrayList<AvailableNetworkInfo> availableNetworks,
+        int periodicity) {
+        RadioAccessSpecifier[] ras;
+        ArrayList<String> mccMncs = new ArrayList<String>();
+        Set<Integer> bandSet5G = new ArraySet<>();
+        Set<Integer> bandSet4G = new ArraySet<>();
+
+        mIs4gScanEnabled = getIs4gScanEnabled();
+
         /* retrieve mcc mncs and bands for available networks */
         for (AvailableNetworkInfo availableNetwork : availableNetworks) {
             mccMncs.addAll(availableNetwork.getMccMncs());
-            bandSet.addAll(availableNetwork.getBands());
+            List<RadioAccessSpecifier> radioAccessSpecifiers =
+                    availableNetwork.getRadioAccessSpecifiers();
+            if (radioAccessSpecifiers.isEmpty()) {
+                if (mIs4gScanEnabled) {
+                    bandSet4G.addAll(availableNetwork.getBands());
+                }
+                bandSet5G.addAll(availableNetwork.getBands());
+            } else {
+                for (RadioAccessSpecifier radioAccessSpecifier : radioAccessSpecifiers) {
+                    int radioAccessNetworkType = radioAccessSpecifier.getRadioAccessNetwork();
+                    if (mIs4gScanEnabled &&
+                            radioAccessNetworkType ==
+                                    AccessNetworkConstants.AccessNetworkType.EUTRAN) {
+                        bandSet4G.addAll(Arrays.stream(radioAccessSpecifier.getBands())
+                                .boxed().collect(Collectors.toList()));
+                    } else if (radioAccessNetworkType ==
+                            AccessNetworkConstants.AccessNetworkType.NGRAN) {
+                        bandSet5G.addAll(Arrays.stream(radioAccessSpecifier.getBands())
+                                .boxed().collect(Collectors.toList()));
+                    }
+                }
+            }
         }
 
-        int[] bands = bandSet.stream().mapToInt(band->band).toArray();
-        /* create network scan request */
-        ras[0] = new RadioAccessSpecifier(AccessNetworkConstants.AccessNetworkType.EUTRAN, bands,
-                null);
+        int rasSize = 1;
+        if (mIs4gScanEnabled && bandSet4G.isEmpty() == bandSet5G.isEmpty()) {
+            rasSize = 2;
+        }
+        ras = new RadioAccessSpecifier[rasSize];
+
+        if (bandSet4G.isEmpty() && bandSet5G.isEmpty()) {
+            // Set the default RadioAccessSpecifiers if none were set and no bands were set.
+            ras[0] = DEFAULT_5G_RAS;
+            if (mIs4gScanEnabled) {
+                ras[1] = DEFAULT_4G_RAS;
+            }
+        } else {
+            if (mIs4gScanEnabled && !bandSet4G.isEmpty()) {
+                ras[0] = new RadioAccessSpecifier(AccessNetworkConstants.AccessNetworkType.EUTRAN,
+                        bandSet4G.stream().mapToInt(band->band).toArray(), null);
+            }
+            if (!bandSet5G.isEmpty()) {
+                ras[rasSize - 1] = new RadioAccessSpecifier(
+                        AccessNetworkConstants.AccessNetworkType.NGRAN,
+                        bandSet5G.stream().mapToInt(band->band).toArray(), null);
+            } else if (!mIs4gScanEnabled) {
+                // Reached if only 4G was specified but 4G scan is disabled.
+                ras[0] = DEFAULT_5G_RAS;
+            }
+        }
+
         NetworkScanRequest networkScanRequest = new NetworkScanRequest(
-                NetworkScanRequest.SCAN_TYPE_PERIODIC, ras, periodicity, MAX_SEARCH_TIME, false,
-                NetworkScanRequest.MAX_INCREMENTAL_PERIODICITY_SEC, mccMncs);
+            NetworkScanRequest.SCAN_TYPE_PERIODIC, ras, periodicity, MAX_SEARCH_TIME, false,
+            NetworkScanRequest.MAX_INCREMENTAL_PERIODICITY_SEC, mccMncs);
         synchronized (mLock) {
             mMccMncs = mccMncs;
         }
@@ -284,6 +390,9 @@
                 getIntCarrierConfig(
                     CarrierConfigManager.KEY_OPPORTUNISTIC_NETWORK_EXIT_THRESHOLD_RSRP_INT);
 
+            mSsRsrpEntryThreshold = getIntCarrierConfig(
+                    CarrierConfigManager.KEY_OPPORTUNISTIC_NETWORK_EXIT_THRESHOLD_SS_RSRP_INT);
+
             /* start new scan */
             networkScan = mTelephonyManager.requestNetworkScan(networkScanRequest,
                     mNetworkScanCallback);
diff --git a/tests/src/com/android/ons/ONSNetworkScanCtlrTest.java b/tests/src/com/android/ons/ONSNetworkScanCtlrTest.java
index ba20467..67f31c2 100644
--- a/tests/src/com/android/ons/ONSNetworkScanCtlrTest.java
+++ b/tests/src/com/android/ons/ONSNetworkScanCtlrTest.java
@@ -20,13 +20,21 @@
 import static org.mockito.Mockito.*;
 
 import android.os.Looper;
+import android.os.PersistableBundle;
+import android.telephony.AccessNetworkConstants;
 import android.telephony.AvailableNetworkInfo;
+import android.telephony.CarrierConfigManager;
 import android.telephony.CellIdentityLte;
 import android.telephony.CellInfo;
 import android.telephony.CellInfoLte;
 import android.telephony.NetworkScan;
+import android.telephony.NetworkScanRequest;
+import android.telephony.RadioAccessSpecifier;
 import android.telephony.SubscriptionInfo;
 import android.telephony.TelephonyManager;
+import android.util.Log;
+
+import androidx.test.InstrumentationRegistry;
 
 import org.junit.After;
 import org.junit.Before;
@@ -35,6 +43,7 @@
 import org.mockito.MockitoAnnotations;
 
 import java.sql.Array;
+import java.util.Arrays;
 import java.util.ArrayList;
 import java.util.List;
 
@@ -46,6 +55,19 @@
     private boolean mCallbackInvoked;
     private Looper mLooper;
 
+    private static final int SEARCH_PERIODICITY = 60;
+    private static final SubscriptionInfo TEST_SUBSCRIPTION_INFO = new SubscriptionInfo(
+            1, "", 1, null, null, 0, 0, null, 0, null, "310", "210", null,
+            false, null, null);
+    private static final RadioAccessSpecifier TEST_5G_RAS = new RadioAccessSpecifier(
+            AccessNetworkConstants.AccessNetworkType.NGRAN,
+            new int[] {AccessNetworkConstants.NgranBands.BAND_71},
+            null);
+    private static final RadioAccessSpecifier TEST_4G_RAS = new RadioAccessSpecifier(
+            AccessNetworkConstants.AccessNetworkType.EUTRAN,
+            new int[] {AccessNetworkConstants.EutranBand.BAND_48},
+            null);
+
     @Before
     public void setUp() throws Exception {
         super.setUp("ONSTest");
@@ -76,35 +98,8 @@
         CellInfoLte cellInfoLte = new CellInfoLte();
         cellInfoLte.setCellIdentity(cellIdentityLte);
         expectedResults.add((CellInfo)cellInfoLte);
-        mReady = false;
 
-        // initializing ONSNetworkScanCtlr
-        new Thread(new Runnable() {
-            @Override
-            public void run() {
-                Looper.prepare();
-                mONSNetworkScanCtlr = new ONSNetworkScanCtlr(mContext, mMockTelephonyManager,
-                        new ONSNetworkScanCtlr.NetworkAvailableCallBack() {
-                        @Override
-                        public void onNetworkAvailability(List<CellInfo> results) {
-                            mResults = results;
-                            setReady(true);
-                        }
-
-                        public void onError(int error) {
-                            setReady(true);
-                        }
-                    });
-
-                mLooper = Looper.myLooper();
-                setReady(true);
-                Looper.loop();
-            }
-        }).start();
-
-        // Wait till initialization is complete.
-        waitUntilReady();
-        mReady = false;
+        initONSNetworkScanCtrl();
 
         // Testing startFastNetworkScan, onNetworkAvailability should be called with expectedResults
         mONSNetworkScanCtlr.startFastNetworkScan(availableNetworkInfos);
@@ -126,38 +121,9 @@
                 new ArrayList<Integer>());
         ArrayList<AvailableNetworkInfo> availableNetworkInfos = new ArrayList<AvailableNetworkInfo>();
         availableNetworkInfos.add(availableNetworkInfo);
-        mReady = false;
         mError = NetworkScan.SUCCESS;
 
-        // initializing ONSNetworkScanCtlr
-        new Thread(new Runnable() {
-            @Override
-            public void run() {
-                Looper.prepare();
-                mONSNetworkScanCtlr = new ONSNetworkScanCtlr(mContext, mMockTelephonyManager,
-                        new ONSNetworkScanCtlr.NetworkAvailableCallBack() {
-                        @Override
-                        public void onNetworkAvailability(List<CellInfo> results) {
-                            setReady(true);
-                        }
-
-                        @Override
-                        public void onError(int error) {
-                            mError = error;
-                            setReady(true);
-                        }
-                    });
-
-                mLooper = Looper.myLooper();
-                setReady(true);
-                Looper.loop();
-
-            }
-        }).start();
-
-        // Wait till initialization is complete.
-        waitUntilReady();
-        mReady = false;
+        initONSNetworkScanCtrl();
 
         // Testing startFastNetworkScan, onError should be called with ERROR_INVALID_SCAN
         mONSNetworkScanCtlr.startFastNetworkScan(availableNetworkInfos);
@@ -180,36 +146,8 @@
             new ArrayList<Integer>());
         ArrayList<AvailableNetworkInfo> availableNetworkInfos = new ArrayList<AvailableNetworkInfo>();
         availableNetworkInfos.add(availableNetworkInfo);
-        mReady = false;
 
-        // initializing ONSNetworkScanCtlr
-        new Thread(new Runnable() {
-            @Override
-            public void run() {
-                Looper.prepare();
-                mONSNetworkScanCtlr = new ONSNetworkScanCtlr(mContext, mMockTelephonyManager,
-                        new ONSNetworkScanCtlr.NetworkAvailableCallBack() {
-                        @Override
-                        public void onNetworkAvailability(List<CellInfo> results) {
-                            mResults = results;
-                            setReady(true);
-                        }
-
-                        public void onError(int error) {
-                            setReady(true);
-                        }
-                    });
-
-                mLooper = Looper.myLooper();
-                setReady(true);
-                Looper.loop();
-
-            }
-        }).start();
-
-        // Wait till initialization is complete.
-        waitUntilReady();
-        mReady = false;
+        initONSNetworkScanCtrl();
 
         // Testing startSlowNetworkScan, onNetworkAvailability should be called with expectedResults
         mONSNetworkScanCtlr.startFastNetworkScan(availableNetworkInfos);
@@ -229,9 +167,149 @@
         mccMncs.add("310210");
         AvailableNetworkInfo availableNetworkInfo = new AvailableNetworkInfo(1, 1, mccMncs,
                 new ArrayList<Integer>());
-        ArrayList<AvailableNetworkInfo> availableNetworkInfos = new ArrayList<AvailableNetworkInfo>();
+        ArrayList<AvailableNetworkInfo> availableNetworkInfos =
+                new ArrayList<AvailableNetworkInfo>();
         availableNetworkInfos.add(availableNetworkInfo);
         mCallbackInvoked = false;
+
+        initONSNetworkScanCtrl();
+
+        // Testing stopNetworkScan, should not get any callback invocation after stopNetworkScan.
+        mONSNetworkScanCtlr.startFastNetworkScan(availableNetworkInfos);
+        mONSNetworkScanCtlr.stopNetworkScan();
+        mONSNetworkScanCtlr.mNetworkScanCallback.onResults(expectedResults);
+        waitUntilReady(100);
+        assertFalse(mCallbackInvoked);
+    }
+
+    @Test
+    public void testCreateNetworkScanRequest_withNoSpecifiedRasOrBands_4gScanEnabled() {
+        initONSNetworkScanCtrl();
+        mONSNetworkScanCtlr.setIs4gScanEnabled(true);
+
+        NetworkScanRequest networkScanRequest = createNetworkScanRequest(new ArrayList<>());
+        RadioAccessSpecifier[] radioAccessSpecifiers = networkScanRequest.getSpecifiers();
+
+        assertEquals(networkScanRequest.getSearchPeriodicity(), SEARCH_PERIODICITY);
+        assertEquals(networkScanRequest.getPlmns().size(), 1);
+        assertEquals(networkScanRequest.getPlmns().get(0), "310210");
+        assertEquals(radioAccessSpecifiers.length, 2);
+        assertEquals(radioAccessSpecifiers[0], ONSNetworkScanCtlr.DEFAULT_5G_RAS);
+        assertEquals(radioAccessSpecifiers[1], ONSNetworkScanCtlr.DEFAULT_4G_RAS);
+    }
+
+    @Test
+    public void testCreateNetworkScanRequest_withNoSpecifiedRasOrBands_4gScanDisabled() {
+        initONSNetworkScanCtrl();
+        mONSNetworkScanCtlr.setIs4gScanEnabled(false);
+
+        NetworkScanRequest networkScanRequest = createNetworkScanRequest(new ArrayList<>());
+        RadioAccessSpecifier[] radioAccessSpecifiers = networkScanRequest.getSpecifiers();
+
+        assertEquals(networkScanRequest.getSearchPeriodicity(), SEARCH_PERIODICITY);
+        assertEquals(networkScanRequest.getPlmns().size(), 1);
+        assertEquals(networkScanRequest.getPlmns().get(0), "310210");
+        assertEquals(radioAccessSpecifiers.length, 1);
+        assertEquals(radioAccessSpecifiers[0], ONSNetworkScanCtlr.DEFAULT_5G_RAS);
+    }
+
+    @Test
+    public void testCreateNetworkScanRequest_withSpecified5gRAS_4gScanEnabled() {
+        initONSNetworkScanCtrl();
+        mONSNetworkScanCtlr.setIs4gScanEnabled(true);
+
+        NetworkScanRequest networkScanRequest = createNetworkScanRequest(
+                new ArrayList<>(Arrays.asList(TEST_5G_RAS)));
+        RadioAccessSpecifier[] radioAccessSpecifiers = networkScanRequest.getSpecifiers();
+
+        assertEquals(networkScanRequest.getSearchPeriodicity(), SEARCH_PERIODICITY);
+        assertEquals(networkScanRequest.getPlmns().size(), 1);
+        assertEquals(networkScanRequest.getPlmns().get(0), "310210");
+        assertEquals(radioAccessSpecifiers.length, 1);
+        assertEquals(radioAccessSpecifiers[0], TEST_5G_RAS);
+    }
+
+    @Test
+    public void testCreateNetworkScanRequest_withSpecified4gRAS_4gScanEnabled() {
+        initONSNetworkScanCtrl();
+        mONSNetworkScanCtlr.setIs4gScanEnabled(true);
+
+        NetworkScanRequest networkScanRequest = createNetworkScanRequest(
+                new ArrayList<>(Arrays.asList(TEST_4G_RAS)));
+        RadioAccessSpecifier[] radioAccessSpecifiers = networkScanRequest.getSpecifiers();
+
+        assertEquals(networkScanRequest.getSearchPeriodicity(), SEARCH_PERIODICITY);
+        assertEquals(networkScanRequest.getPlmns().size(), 1);
+        assertEquals(networkScanRequest.getPlmns().get(0), "310210");
+        assertEquals(radioAccessSpecifiers.length, 1);
+        assertEquals(radioAccessSpecifiers[0], TEST_4G_RAS);
+    }
+
+    @Test
+    public void testCreateNetworkScanRequest_withSpecified4gRAS_4gScanDisabled() {
+        initONSNetworkScanCtrl();
+        mONSNetworkScanCtlr.setIs4gScanEnabled(false);
+
+        NetworkScanRequest networkScanRequest = createNetworkScanRequest(
+                new ArrayList<>(Arrays.asList(TEST_4G_RAS)));
+        RadioAccessSpecifier[] radioAccessSpecifiers = networkScanRequest.getSpecifiers();
+
+        assertEquals(networkScanRequest.getSearchPeriodicity(), SEARCH_PERIODICITY);
+        assertEquals(networkScanRequest.getPlmns().size(), 1);
+        assertEquals(networkScanRequest.getPlmns().get(0), "310210");
+        assertEquals(radioAccessSpecifiers.length, 1);
+        assertEquals(radioAccessSpecifiers[0], ONSNetworkScanCtlr.DEFAULT_5G_RAS);
+    }
+
+    @Test
+    public void testCreateNetworkScanRequest_withSpecified4gAnd5gRAS_4gScanEnabled() {
+        initONSNetworkScanCtrl();
+        mONSNetworkScanCtlr.setIs4gScanEnabled(true);
+
+        NetworkScanRequest networkScanRequest = createNetworkScanRequest(
+                new ArrayList<>(Arrays.asList(TEST_5G_RAS, TEST_4G_RAS)));
+        RadioAccessSpecifier[] radioAccessSpecifiers = networkScanRequest.getSpecifiers();
+
+        assertEquals(networkScanRequest.getSearchPeriodicity(), SEARCH_PERIODICITY);
+        assertEquals(networkScanRequest.getPlmns().size(), 1);
+        assertEquals(networkScanRequest.getPlmns().get(0), "310210");
+        assertEquals(radioAccessSpecifiers.length, 2);
+        assertEquals(radioAccessSpecifiers[0], TEST_4G_RAS);
+        assertEquals(radioAccessSpecifiers[1], TEST_5G_RAS);
+    }
+
+    @Test
+    public void testCreateNetworkScanRequest_withSpecified4gAnd5gRAS_4gScanDisabled() {
+        initONSNetworkScanCtrl();
+        mONSNetworkScanCtlr.setIs4gScanEnabled(false);
+
+        NetworkScanRequest networkScanRequest = createNetworkScanRequest(
+                new ArrayList<>(Arrays.asList(TEST_5G_RAS, TEST_4G_RAS)));
+        RadioAccessSpecifier[] radioAccessSpecifiers = networkScanRequest.getSpecifiers();
+
+        assertEquals(networkScanRequest.getSearchPeriodicity(), SEARCH_PERIODICITY);
+        assertEquals(networkScanRequest.getPlmns().size(), 1);
+        assertEquals(networkScanRequest.getPlmns().get(0), "310210");
+        assertEquals(radioAccessSpecifiers.length, 1);
+        assertEquals(radioAccessSpecifiers[0], TEST_5G_RAS);
+    }
+
+    private NetworkScanRequest createNetworkScanRequest(ArrayList<RadioAccessSpecifier> ras) {
+        AvailableNetworkInfo availableNetworkInfo = new AvailableNetworkInfo.Builder()
+                .setSubId(TEST_SUBSCRIPTION_INFO.getSubscriptionId())
+                .setPriority(AvailableNetworkInfo.PRIORITY_LOW)
+                .setMccMncs(new ArrayList<>(Arrays.asList("310210")))
+                .setRadioAccessSpecifiers(ras)
+                .build();
+        ArrayList<AvailableNetworkInfo> availableNetworkInfos =
+            new ArrayList<AvailableNetworkInfo>();
+        availableNetworkInfos.add(availableNetworkInfo);
+
+        return mONSNetworkScanCtlr.createNetworkScanRequest(availableNetworkInfos,
+                SEARCH_PERIODICITY);
+    }
+
+    private void initONSNetworkScanCtrl() {
         mReady = false;
 
         // initializing ONSNetworkScanCtlr
@@ -240,15 +318,16 @@
             public void run() {
                 Looper.prepare();
                 mONSNetworkScanCtlr = new ONSNetworkScanCtlr(mContext, mMockTelephonyManager,
-                        new ONSNetworkScanCtlr.NetworkAvailableCallBack() {
+                    new ONSNetworkScanCtlr.NetworkAvailableCallBack() {
                         @Override
                         public void onNetworkAvailability(List<CellInfo> results) {
-                            mCallbackInvoked = true;
+                            mResults = results;
                             setReady(true);
                         }
 
                         public void onError(int error) {
-                            mCallbackInvoked = true;
+                            mError = error;
+                            setReady(true);
                         }
                     });
 
@@ -261,12 +340,5 @@
         // Wait till initialization is complete.
         waitUntilReady();
         mReady = false;
-
-        // Testing stopNetworkScan, should not get any callback invocation after stopNetworkScan.
-        mONSNetworkScanCtlr.startFastNetworkScan(availableNetworkInfos);
-        mONSNetworkScanCtlr.stopNetworkScan();
-        mONSNetworkScanCtlr.mNetworkScanCallback.onResults(expectedResults);
-        waitUntilReady(100);
-        assertFalse(mCallbackInvoked);
     }
 }