1 /*
2  * Copyright (C) 2018 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.ons;
17 
18 import static org.junit.Assert.*;
19 import static org.junit.Assert.assertFalse;
20 import static org.mockito.Mockito.*;
21 
22 import android.os.Looper;
23 import android.os.PersistableBundle;
24 import android.telephony.AccessNetworkConstants;
25 import android.telephony.AvailableNetworkInfo;
26 import android.telephony.CarrierConfigManager;
27 import android.telephony.CellIdentityLte;
28 import android.telephony.CellInfo;
29 import android.telephony.CellInfoLte;
30 import android.telephony.NetworkScan;
31 import android.telephony.NetworkScanRequest;
32 import android.telephony.RadioAccessSpecifier;
33 import android.telephony.SubscriptionInfo;
34 import android.telephony.TelephonyManager;
35 import android.util.Log;
36 
37 import androidx.test.InstrumentationRegistry;
38 
39 import org.junit.After;
40 import org.junit.Before;
41 import org.junit.Test;
42 import org.mockito.Mock;
43 import org.mockito.MockitoAnnotations;
44 
45 import java.sql.Array;
46 import java.util.Arrays;
47 import java.util.ArrayList;
48 import java.util.List;
49 
50 public class ONSNetworkScanCtlrTest extends ONSBaseTest {
51     private ONSNetworkScanCtlr mONSNetworkScanCtlr;
52     private NetworkScan mNetworkScan;
53     private List<CellInfo> mResults;
54     private int mError;
55     private boolean mCallbackInvoked;
56     private Looper mLooper;
57 
58     private static final int SEARCH_PERIODICITY = 60;
59     private static final SubscriptionInfo TEST_SUBSCRIPTION_INFO = new SubscriptionInfo(
60             1, "", 1, null, null, 0, 0, null, 0, null, "310", "210", null,
61             false, null, null);
62     private static final RadioAccessSpecifier TEST_5G_RAS = new RadioAccessSpecifier(
63             AccessNetworkConstants.AccessNetworkType.NGRAN,
64             new int[] {AccessNetworkConstants.NgranBands.BAND_71},
65             null);
66     private static final RadioAccessSpecifier TEST_4G_RAS = new RadioAccessSpecifier(
67             AccessNetworkConstants.AccessNetworkType.EUTRAN,
68             new int[] {AccessNetworkConstants.EutranBand.BAND_48},
69             null);
70 
71     @Before
setUp()72     public void setUp() throws Exception {
73         super.setUp("ONSTest");
74         mLooper = null;
75         mNetworkScan = new NetworkScan(1, 1);
76         doReturn(mNetworkScan).when(mMockTelephonyManager).requestNetworkScan(anyObject(), anyObject());
77     }
78 
79     @After
tearDown()80     public void tearDown() throws Exception {
81         if (mLooper != null) {
82             mLooper.quit();
83             mLooper.getThread().join();
84         }
85         super.tearDown();
86     }
87 
88     @Test
testStartFastNetworkScan()89     public void testStartFastNetworkScan() {
90         ArrayList<String> mccMncs = new ArrayList<>();
91         mccMncs.add("310210");
92         AvailableNetworkInfo availableNetworkInfo = new AvailableNetworkInfo(1, 1, mccMncs,
93                 new ArrayList<Integer>());
94         ArrayList<AvailableNetworkInfo> availableNetworkInfos = new ArrayList<AvailableNetworkInfo>();
95         availableNetworkInfos.add(availableNetworkInfo);
96         List<CellInfo> expectedResults = new ArrayList<CellInfo>();
97         CellIdentityLte cellIdentityLte = new CellIdentityLte(310, 210, 1, 1, 1);
98         CellInfoLte cellInfoLte = new CellInfoLte();
99         cellInfoLte.setCellIdentity(cellIdentityLte);
100         expectedResults.add((CellInfo)cellInfoLte);
101 
102         initONSNetworkScanCtrl();
103 
104         // Testing startFastNetworkScan, onNetworkAvailability should be called with expectedResults
105         mONSNetworkScanCtlr.startFastNetworkScan(availableNetworkInfos);
106         mONSNetworkScanCtlr.mNetworkScanCallback.onResults(expectedResults);
107         waitUntilReady(100);
108         assertEquals(expectedResults, mResults);
109     }
110 
111     @Test
testStartFastNetworkScanFail()112     public void testStartFastNetworkScanFail() {
113         List<CellInfo> expectedResults = new ArrayList<CellInfo>();
114         CellIdentityLte cellIdentityLte = new CellIdentityLte(310, 210, 1, 1, 1);
115         CellInfoLte cellInfoLte = new CellInfoLte();
116         cellInfoLte.setCellIdentity(cellIdentityLte);
117         expectedResults.add((CellInfo)cellInfoLte);
118         ArrayList<String> mccMncs = new ArrayList<>();
119         mccMncs.add("310210");
120         AvailableNetworkInfo availableNetworkInfo = new AvailableNetworkInfo(1, 1, mccMncs,
121                 new ArrayList<Integer>());
122         ArrayList<AvailableNetworkInfo> availableNetworkInfos = new ArrayList<AvailableNetworkInfo>();
123         availableNetworkInfos.add(availableNetworkInfo);
124         mError = NetworkScan.SUCCESS;
125 
126         initONSNetworkScanCtrl();
127 
128         // Testing startFastNetworkScan, onError should be called with ERROR_INVALID_SCAN
129         mONSNetworkScanCtlr.startFastNetworkScan(availableNetworkInfos);
130         mONSNetworkScanCtlr.mNetworkScanCallback.onError(NetworkScan.ERROR_INVALID_SCAN);
131         waitUntilReady(100);
132         assertEquals(NetworkScan.ERROR_INVALID_SCAN, mError);
133     }
134 
135     @Test
testStartFastNetworkScanWithMultipleNetworks()136     public void testStartFastNetworkScanWithMultipleNetworks() {
137         List<CellInfo> expectedResults = new ArrayList<CellInfo>();
138         CellIdentityLte cellIdentityLte = new CellIdentityLte(310, 210, 1, 1, 1);
139         CellInfoLte cellInfoLte = new CellInfoLte();
140         cellInfoLte.setCellIdentity(cellIdentityLte);
141         expectedResults.add((CellInfo)cellInfoLte);
142         ArrayList<String> mccMncs = new ArrayList<>();
143         mccMncs.add("310210");
144         mccMncs.add("310211");
145         AvailableNetworkInfo availableNetworkInfo = new AvailableNetworkInfo(1, 1, mccMncs,
146             new ArrayList<Integer>());
147         ArrayList<AvailableNetworkInfo> availableNetworkInfos = new ArrayList<AvailableNetworkInfo>();
148         availableNetworkInfos.add(availableNetworkInfo);
149 
150         initONSNetworkScanCtrl();
151 
152         // Testing startSlowNetworkScan, onNetworkAvailability should be called with expectedResults
153         mONSNetworkScanCtlr.startFastNetworkScan(availableNetworkInfos);
154         mONSNetworkScanCtlr.mNetworkScanCallback.onResults(expectedResults);
155         waitUntilReady(100);
156         assertEquals(expectedResults, mResults);
157     }
158 
159     @Test
testStopNetworkScan()160     public void testStopNetworkScan() {
161         List<CellInfo> expectedResults = new ArrayList<CellInfo>();
162         CellIdentityLte cellIdentityLte = new CellIdentityLte(310, 210, 1, 1, 1);
163         CellInfoLte cellInfoLte = new CellInfoLte();
164         cellInfoLte.setCellIdentity(cellIdentityLte);
165         expectedResults.add((CellInfo)cellInfoLte);
166         ArrayList<String> mccMncs = new ArrayList<>();
167         mccMncs.add("310210");
168         AvailableNetworkInfo availableNetworkInfo = new AvailableNetworkInfo(1, 1, mccMncs,
169                 new ArrayList<Integer>());
170         ArrayList<AvailableNetworkInfo> availableNetworkInfos =
171                 new ArrayList<AvailableNetworkInfo>();
172         availableNetworkInfos.add(availableNetworkInfo);
173         mCallbackInvoked = false;
174 
175         initONSNetworkScanCtrl();
176 
177         // Testing stopNetworkScan, should not get any callback invocation after stopNetworkScan.
178         mONSNetworkScanCtlr.startFastNetworkScan(availableNetworkInfos);
179         mONSNetworkScanCtlr.stopNetworkScan();
180         mONSNetworkScanCtlr.mNetworkScanCallback.onResults(expectedResults);
181         waitUntilReady(100);
182         assertFalse(mCallbackInvoked);
183     }
184 
185     @Test
testCreateNetworkScanRequest_withNoSpecifiedRasOrBands_4gScanEnabled()186     public void testCreateNetworkScanRequest_withNoSpecifiedRasOrBands_4gScanEnabled() {
187         initONSNetworkScanCtrl();
188         mONSNetworkScanCtlr.setIs4gScanEnabled(true);
189 
190         NetworkScanRequest networkScanRequest = createNetworkScanRequest(new ArrayList<>());
191         RadioAccessSpecifier[] radioAccessSpecifiers = networkScanRequest.getSpecifiers();
192 
193         assertEquals(networkScanRequest.getSearchPeriodicity(), SEARCH_PERIODICITY);
194         assertEquals(networkScanRequest.getPlmns().size(), 1);
195         assertEquals(networkScanRequest.getPlmns().get(0), "310210");
196         assertEquals(radioAccessSpecifiers.length, 2);
197         assertEquals(radioAccessSpecifiers[0], ONSNetworkScanCtlr.DEFAULT_5G_RAS);
198         assertEquals(radioAccessSpecifiers[1], ONSNetworkScanCtlr.DEFAULT_4G_RAS);
199     }
200 
201     @Test
testCreateNetworkScanRequest_withNoSpecifiedRasOrBands_4gScanDisabled()202     public void testCreateNetworkScanRequest_withNoSpecifiedRasOrBands_4gScanDisabled() {
203         initONSNetworkScanCtrl();
204         mONSNetworkScanCtlr.setIs4gScanEnabled(false);
205 
206         NetworkScanRequest networkScanRequest = createNetworkScanRequest(new ArrayList<>());
207         RadioAccessSpecifier[] radioAccessSpecifiers = networkScanRequest.getSpecifiers();
208 
209         assertEquals(networkScanRequest.getSearchPeriodicity(), SEARCH_PERIODICITY);
210         assertEquals(networkScanRequest.getPlmns().size(), 1);
211         assertEquals(networkScanRequest.getPlmns().get(0), "310210");
212         assertEquals(radioAccessSpecifiers.length, 1);
213         assertEquals(radioAccessSpecifiers[0], ONSNetworkScanCtlr.DEFAULT_5G_RAS);
214     }
215 
216     @Test
testCreateNetworkScanRequest_withSpecified5gRAS_4gScanEnabled()217     public void testCreateNetworkScanRequest_withSpecified5gRAS_4gScanEnabled() {
218         initONSNetworkScanCtrl();
219         mONSNetworkScanCtlr.setIs4gScanEnabled(true);
220 
221         NetworkScanRequest networkScanRequest = createNetworkScanRequest(
222                 new ArrayList<>(Arrays.asList(TEST_5G_RAS)));
223         RadioAccessSpecifier[] radioAccessSpecifiers = networkScanRequest.getSpecifiers();
224 
225         assertEquals(networkScanRequest.getSearchPeriodicity(), SEARCH_PERIODICITY);
226         assertEquals(networkScanRequest.getPlmns().size(), 1);
227         assertEquals(networkScanRequest.getPlmns().get(0), "310210");
228         assertEquals(radioAccessSpecifiers.length, 1);
229         assertEquals(radioAccessSpecifiers[0], TEST_5G_RAS);
230     }
231 
232     @Test
testCreateNetworkScanRequest_withSpecified4gRAS_4gScanEnabled()233     public void testCreateNetworkScanRequest_withSpecified4gRAS_4gScanEnabled() {
234         initONSNetworkScanCtrl();
235         mONSNetworkScanCtlr.setIs4gScanEnabled(true);
236 
237         NetworkScanRequest networkScanRequest = createNetworkScanRequest(
238                 new ArrayList<>(Arrays.asList(TEST_4G_RAS)));
239         RadioAccessSpecifier[] radioAccessSpecifiers = networkScanRequest.getSpecifiers();
240 
241         assertEquals(networkScanRequest.getSearchPeriodicity(), SEARCH_PERIODICITY);
242         assertEquals(networkScanRequest.getPlmns().size(), 1);
243         assertEquals(networkScanRequest.getPlmns().get(0), "310210");
244         assertEquals(radioAccessSpecifiers.length, 1);
245         assertEquals(radioAccessSpecifiers[0], TEST_4G_RAS);
246     }
247 
248     @Test
testCreateNetworkScanRequest_withSpecified4gRAS_4gScanDisabled()249     public void testCreateNetworkScanRequest_withSpecified4gRAS_4gScanDisabled() {
250         initONSNetworkScanCtrl();
251         mONSNetworkScanCtlr.setIs4gScanEnabled(false);
252 
253         NetworkScanRequest networkScanRequest = createNetworkScanRequest(
254                 new ArrayList<>(Arrays.asList(TEST_4G_RAS)));
255         RadioAccessSpecifier[] radioAccessSpecifiers = networkScanRequest.getSpecifiers();
256 
257         assertEquals(networkScanRequest.getSearchPeriodicity(), SEARCH_PERIODICITY);
258         assertEquals(networkScanRequest.getPlmns().size(), 1);
259         assertEquals(networkScanRequest.getPlmns().get(0), "310210");
260         assertEquals(radioAccessSpecifiers.length, 1);
261         assertEquals(radioAccessSpecifiers[0], ONSNetworkScanCtlr.DEFAULT_5G_RAS);
262     }
263 
264     @Test
testCreateNetworkScanRequest_withSpecified4gAnd5gRAS_4gScanEnabled()265     public void testCreateNetworkScanRequest_withSpecified4gAnd5gRAS_4gScanEnabled() {
266         initONSNetworkScanCtrl();
267         mONSNetworkScanCtlr.setIs4gScanEnabled(true);
268 
269         NetworkScanRequest networkScanRequest = createNetworkScanRequest(
270                 new ArrayList<>(Arrays.asList(TEST_5G_RAS, TEST_4G_RAS)));
271         RadioAccessSpecifier[] radioAccessSpecifiers = networkScanRequest.getSpecifiers();
272 
273         assertEquals(networkScanRequest.getSearchPeriodicity(), SEARCH_PERIODICITY);
274         assertEquals(networkScanRequest.getPlmns().size(), 1);
275         assertEquals(networkScanRequest.getPlmns().get(0), "310210");
276         assertEquals(radioAccessSpecifiers.length, 2);
277         assertEquals(radioAccessSpecifiers[0], TEST_4G_RAS);
278         assertEquals(radioAccessSpecifiers[1], TEST_5G_RAS);
279     }
280 
281     @Test
testCreateNetworkScanRequest_withSpecified4gAnd5gRAS_4gScanDisabled()282     public void testCreateNetworkScanRequest_withSpecified4gAnd5gRAS_4gScanDisabled() {
283         initONSNetworkScanCtrl();
284         mONSNetworkScanCtlr.setIs4gScanEnabled(false);
285 
286         NetworkScanRequest networkScanRequest = createNetworkScanRequest(
287                 new ArrayList<>(Arrays.asList(TEST_5G_RAS, TEST_4G_RAS)));
288         RadioAccessSpecifier[] radioAccessSpecifiers = networkScanRequest.getSpecifiers();
289 
290         assertEquals(networkScanRequest.getSearchPeriodicity(), SEARCH_PERIODICITY);
291         assertEquals(networkScanRequest.getPlmns().size(), 1);
292         assertEquals(networkScanRequest.getPlmns().get(0), "310210");
293         assertEquals(radioAccessSpecifiers.length, 1);
294         assertEquals(radioAccessSpecifiers[0], TEST_5G_RAS);
295     }
296 
createNetworkScanRequest(ArrayList<RadioAccessSpecifier> ras)297     private NetworkScanRequest createNetworkScanRequest(ArrayList<RadioAccessSpecifier> ras) {
298         AvailableNetworkInfo availableNetworkInfo = new AvailableNetworkInfo.Builder()
299                 .setSubId(TEST_SUBSCRIPTION_INFO.getSubscriptionId())
300                 .setPriority(AvailableNetworkInfo.PRIORITY_LOW)
301                 .setMccMncs(new ArrayList<>(Arrays.asList("310210")))
302                 .setRadioAccessSpecifiers(ras)
303                 .build();
304         ArrayList<AvailableNetworkInfo> availableNetworkInfos =
305             new ArrayList<AvailableNetworkInfo>();
306         availableNetworkInfos.add(availableNetworkInfo);
307 
308         return mONSNetworkScanCtlr.createNetworkScanRequest(availableNetworkInfos,
309                 SEARCH_PERIODICITY);
310     }
311 
initONSNetworkScanCtrl()312     private void initONSNetworkScanCtrl() {
313         mReady = false;
314 
315         // initializing ONSNetworkScanCtlr
316         new Thread(new Runnable() {
317             @Override
318             public void run() {
319                 Looper.prepare();
320                 mONSNetworkScanCtlr = new ONSNetworkScanCtlr(mContext, mMockTelephonyManager,
321                     new ONSNetworkScanCtlr.NetworkAvailableCallBack() {
322                         @Override
323                         public void onNetworkAvailability(List<CellInfo> results) {
324                             mResults = results;
325                             setReady(true);
326                         }
327 
328                         public void onError(int error) {
329                             mError = error;
330                             setReady(true);
331                         }
332                     });
333 
334                 mLooper = Looper.myLooper();
335                 setReady(true);
336                 Looper.loop();
337             }
338         }).start();
339 
340         // Wait till initialization is complete.
341         waitUntilReady();
342         mReady = false;
343     }
344 }
345