1 /*
2  * Copyright 2020 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 
17 package com.google.android.iwlan;
18 
19 import static com.android.dx.mockito.inline.extended.ExtendedMockito.mockitoSession;
20 
21 import static org.junit.Assert.*;
22 import static org.mockito.Mockito.*;
23 
24 import android.content.Context;
25 import android.net.ConnectivityManager;
26 import android.telephony.AccessNetworkConstants;
27 import android.telephony.INetworkService;
28 import android.telephony.INetworkServiceCallback;
29 import android.telephony.NetworkRegistrationInfo;
30 import android.telephony.NetworkServiceCallback;
31 import android.telephony.SubscriptionInfo;
32 import android.telephony.SubscriptionManager;
33 import android.telephony.TelephonyManager;
34 
35 import com.google.android.iwlan.IwlanNetworkService.IwlanNetworkServiceProvider;
36 
37 import org.junit.After;
38 import org.junit.Before;
39 import org.junit.Test;
40 import org.mockito.Mock;
41 import org.mockito.MockitoAnnotations;
42 import org.mockito.MockitoSession;
43 
44 import java.util.Arrays;
45 
46 public class IwlanNetworkServiceTest {
47     private static final String TAG = IwlanNetworkServiceTest.class.getSimpleName();
48     private static final int DEFAULT_SLOT_INDEX = 0;
49 
50     @Mock private Context mMockContext;
51     @Mock private ConnectivityManager mMockConnectivityManager;
52     @Mock private SubscriptionManager mMockSubscriptionManager;
53     @Mock private SubscriptionInfo mMockSubscriptionInfo;
54     @Mock private INetworkServiceCallback mCallback;
55     MockitoSession mStaticMockSession;
56 
57     IwlanNetworkService mIwlanNetworkService;
58     INetworkService mBinder;
59     IwlanNetworkServiceProvider mIwlanNetworkServiceProvider;
60 
61     @Before
setUp()62     public void setUp() throws Exception {
63         MockitoAnnotations.initMocks(this);
64 
65         mStaticMockSession =
66                 mockitoSession()
67                         .mockStatic(IwlanHelper.class)
68                         .mockStatic(SubscriptionManager.class)
69                         .startMocking();
70 
71         when(mMockContext.getSystemService(eq(ConnectivityManager.class)))
72                 .thenReturn(mMockConnectivityManager);
73 
74         when(mMockContext.getSystemService(eq(SubscriptionManager.class)))
75                 .thenReturn(mMockSubscriptionManager);
76 
77         when(mMockSubscriptionManager.getActiveSubscriptionInfoForSimSlotIndex(
78                         eq(DEFAULT_SLOT_INDEX)))
79                 .thenReturn(mMockSubscriptionInfo);
80 
81         lenient()
82                 .when(SubscriptionManager.from(eq(mMockContext)))
83                 .thenReturn(mMockSubscriptionManager);
84 
85         mIwlanNetworkService = new IwlanNetworkService();
86         mIwlanNetworkService.setAppContext(mMockContext);
87         mIwlanNetworkServiceProvider = null;
88 
89         mBinder = mIwlanNetworkService.mBinder;
90         mBinder.createNetworkServiceProvider(DEFAULT_SLOT_INDEX);
91         mBinder.registerForNetworkRegistrationInfoChanged(DEFAULT_SLOT_INDEX, mCallback);
92     }
93 
94     @After
cleanUp()95     public void cleanUp() throws Exception {
96         mBinder.removeNetworkServiceProvider(DEFAULT_SLOT_INDEX);
97         mStaticMockSession.finishMocking();
98     }
99 
100     @Test
testRequestNetworkRegistrationInfo()101     public void testRequestNetworkRegistrationInfo() throws Exception {
102         int domain = NetworkRegistrationInfo.DOMAIN_PS;
103         boolean mIsSubActive = true;
104         long startTime;
105 
106         // Wait for IwlanNetworkServiceProvider created and timeout is 1 second.
107         startTime = System.currentTimeMillis();
108         while (System.currentTimeMillis() - startTime < 1000) {
109             mIwlanNetworkServiceProvider =
110                     mIwlanNetworkService.getNetworkServiceProvider(DEFAULT_SLOT_INDEX);
111             if (mIwlanNetworkServiceProvider != null) {
112                 break;
113             }
114         }
115 
116         assertTrue(mIwlanNetworkServiceProvider != null);
117 
118         // Set Wifi on and verify mCallback should receive onNetworkStateChanged.
119         mIwlanNetworkService.setNetworkConnected(true, IwlanNetworkService.Transport.WIFI);
120         verify(mCallback, timeout(1000).times(1)).onNetworkStateChanged();
121 
122         // Set Sub active and verify mCallback should receive onNetworkStateChanged.
123         mIwlanNetworkServiceProvider.subscriptionChanged();
124         verify(mCallback, timeout(1000).times(2)).onNetworkStateChanged();
125 
126         // Create expected NetworkRegistrationInfo
127         NetworkRegistrationInfo.Builder expectedStateBuilder =
128                 generateStateBuilder(
129                         domain, mIsSubActive, NetworkRegistrationInfo.REGISTRATION_STATE_HOME);
130 
131         mBinder.requestNetworkRegistrationInfo(0, domain, mCallback);
132 
133         verify(mCallback, timeout(1000).times(1))
134                 .onRequestNetworkRegistrationInfoComplete(
135                         eq(NetworkServiceCallback.RESULT_SUCCESS),
136                         eq(expectedStateBuilder.build()));
137 
138         IwlanNetworkService.setNetworkConnected(
139                 false, IwlanNetworkService.Transport.UNSPECIFIED_NETWORK);
140     }
141 
142     @Test
testNetworkRegistrationInfoForCellularAndCstDisabled()143     public void testNetworkRegistrationInfoForCellularAndCstDisabled() throws Exception {
144         int domain = NetworkRegistrationInfo.DOMAIN_PS;
145         boolean mIsSubActive = true;
146         long startTime;
147 
148         // Wait for IwlanNetworkServiceProvider created and timeout is 1 second.
149         startTime = System.currentTimeMillis();
150         while (System.currentTimeMillis() - startTime < 1000) {
151             mIwlanNetworkServiceProvider =
152                     mIwlanNetworkService.getNetworkServiceProvider(DEFAULT_SLOT_INDEX);
153             if (mIwlanNetworkServiceProvider != null) {
154                 break;
155             }
156         }
157 
158         lenient()
159                 .when(
160                         IwlanHelper.isCrossSimCallingEnabled(
161                                 eq(mMockContext), eq(DEFAULT_SLOT_INDEX)))
162                 .thenReturn(false);
163         lenient()
164                 .when(IwlanHelper.isDefaultDataSlot(eq(mMockContext), eq(DEFAULT_SLOT_INDEX)))
165                 .thenReturn(true);
166 
167         assertTrue(mIwlanNetworkServiceProvider != null);
168 
169         // Set Network on and verify mCallback should receive onNetworkStateChanged.
170         mIwlanNetworkService.setNetworkConnected(true, IwlanNetworkService.Transport.MOBILE);
171         verify(mCallback, timeout(1000).times(1)).onNetworkStateChanged();
172 
173         // Set Sub active and verify mCallback should receive onNetworkStateChanged.
174         mIwlanNetworkServiceProvider.subscriptionChanged();
175         verify(mCallback, timeout(1000).times(2)).onNetworkStateChanged();
176 
177         // Create expected NetworkRegistrationInfo
178         NetworkRegistrationInfo.Builder expectedStateBuilder =
179                 generateStateBuilder(
180                         domain,
181                         mIsSubActive,
182                         NetworkRegistrationInfo.REGISTRATION_STATE_NOT_REGISTERED_SEARCHING);
183 
184         mBinder.requestNetworkRegistrationInfo(0, domain, mCallback);
185 
186         verify(mCallback, timeout(1000).times(1))
187                 .onRequestNetworkRegistrationInfoComplete(
188                         eq(NetworkServiceCallback.RESULT_SUCCESS),
189                         eq(expectedStateBuilder.build()));
190 
191         IwlanNetworkService.setNetworkConnected(
192                 false, IwlanNetworkService.Transport.UNSPECIFIED_NETWORK);
193     }
194 
195     @Test
testNetworkRegistrationInfoForCellularAndCstEnabled()196     public void testNetworkRegistrationInfoForCellularAndCstEnabled() throws Exception {
197         int domain = NetworkRegistrationInfo.DOMAIN_PS;
198         boolean mIsSubActive = true;
199         long startTime;
200 
201         // Wait for IwlanNetworkServiceProvider created and timeout is 1 second.
202         startTime = System.currentTimeMillis();
203         while (System.currentTimeMillis() - startTime < 1000) {
204             mIwlanNetworkServiceProvider =
205                     mIwlanNetworkService.getNetworkServiceProvider(DEFAULT_SLOT_INDEX);
206             if (mIwlanNetworkServiceProvider != null) {
207                 break;
208             }
209         }
210 
211         lenient()
212                 .when(
213                         IwlanHelper.isCrossSimCallingEnabled(
214                                 eq(mMockContext), eq(DEFAULT_SLOT_INDEX)))
215                 .thenReturn(true);
216         lenient()
217                 .when(IwlanHelper.isDefaultDataSlot(eq(mMockContext), eq(DEFAULT_SLOT_INDEX)))
218                 .thenReturn(false);
219 
220         assertTrue(mIwlanNetworkServiceProvider != null);
221 
222         // Set Network on and verify mCallback should receive onNetworkStateChanged.
223         mIwlanNetworkService.setNetworkConnected(true, IwlanNetworkService.Transport.MOBILE);
224         verify(mCallback, timeout(1000).times(1)).onNetworkStateChanged();
225 
226         // Set Sub active and verify mCallback should receive onNetworkStateChanged.
227         mIwlanNetworkServiceProvider.subscriptionChanged();
228         verify(mCallback, timeout(1000).times(2)).onNetworkStateChanged();
229 
230         // Create expected NetworkRegistrationInfo
231         NetworkRegistrationInfo.Builder expectedStateBuilder =
232                 generateStateBuilder(
233                         domain, mIsSubActive, NetworkRegistrationInfo.REGISTRATION_STATE_HOME);
234 
235         mBinder.requestNetworkRegistrationInfo(0, domain, mCallback);
236 
237         verify(mCallback, timeout(1000).times(1))
238                 .onRequestNetworkRegistrationInfoComplete(
239                         eq(NetworkServiceCallback.RESULT_SUCCESS),
240                         eq(expectedStateBuilder.build()));
241 
242         IwlanNetworkService.setNetworkConnected(
243                 false, IwlanNetworkService.Transport.UNSPECIFIED_NETWORK);
244     }
245 
246     @Test
testNetworkRegistrationInfoForWiFiAndCstEnabled()247     public void testNetworkRegistrationInfoForWiFiAndCstEnabled() throws Exception {
248         int domain = NetworkRegistrationInfo.DOMAIN_PS;
249         boolean mIsSubActive = true;
250         long startTime;
251 
252         // Wait for IwlanNetworkServiceProvider created and timeout is 1 second.
253         startTime = System.currentTimeMillis();
254         while (System.currentTimeMillis() - startTime < 1000) {
255             mIwlanNetworkServiceProvider =
256                     mIwlanNetworkService.getNetworkServiceProvider(DEFAULT_SLOT_INDEX);
257             if (mIwlanNetworkServiceProvider != null) {
258                 break;
259             }
260         }
261 
262         lenient()
263                 .when(
264                         IwlanHelper.isCrossSimCallingEnabled(
265                                 eq(mMockContext), eq(DEFAULT_SLOT_INDEX)))
266                 .thenReturn(true);
267         lenient()
268                 .when(IwlanHelper.isDefaultDataSlot(eq(mMockContext), eq(DEFAULT_SLOT_INDEX)))
269                 .thenReturn(true);
270 
271         assertTrue(mIwlanNetworkServiceProvider != null);
272 
273         // Set Network on and verify mCallback should receive onNetworkStateChanged.
274         mIwlanNetworkService.setNetworkConnected(true, IwlanNetworkService.Transport.WIFI);
275         verify(mCallback, timeout(1000).times(1)).onNetworkStateChanged();
276 
277         // Set Sub active and verify mCallback should receive onNetworkStateChanged.
278         mIwlanNetworkServiceProvider.subscriptionChanged();
279         verify(mCallback, timeout(1000).times(2)).onNetworkStateChanged();
280 
281         // Create expected NetworkRegistrationInfo
282         NetworkRegistrationInfo.Builder expectedStateBuilder =
283                 generateStateBuilder(
284                         domain, mIsSubActive, NetworkRegistrationInfo.REGISTRATION_STATE_HOME);
285 
286         mBinder.requestNetworkRegistrationInfo(0, domain, mCallback);
287 
288         verify(mCallback, timeout(1000).times(1))
289                 .onRequestNetworkRegistrationInfoComplete(
290                         eq(NetworkServiceCallback.RESULT_SUCCESS),
291                         eq(expectedStateBuilder.build()));
292 
293         IwlanNetworkService.setNetworkConnected(
294                 false, IwlanNetworkService.Transport.UNSPECIFIED_NETWORK);
295     }
296 
297     @Test
testNetworkRegistrationInfoForWiFiAndCstDisabled()298     public void testNetworkRegistrationInfoForWiFiAndCstDisabled() throws Exception {
299         int domain = NetworkRegistrationInfo.DOMAIN_PS;
300         boolean mIsSubActive = true;
301         long startTime;
302 
303         // Wait for IwlanNetworkServiceProvider created and timeout is 1 second.
304         startTime = System.currentTimeMillis();
305         while (System.currentTimeMillis() - startTime < 1000) {
306             mIwlanNetworkServiceProvider =
307                     mIwlanNetworkService.getNetworkServiceProvider(DEFAULT_SLOT_INDEX);
308             if (mIwlanNetworkServiceProvider != null) {
309                 break;
310             }
311         }
312 
313         lenient()
314                 .when(
315                         IwlanHelper.isCrossSimCallingEnabled(
316                                 eq(mMockContext), eq(DEFAULT_SLOT_INDEX)))
317                 .thenReturn(false);
318         lenient()
319                 .when(IwlanHelper.isDefaultDataSlot(eq(mMockContext), eq(DEFAULT_SLOT_INDEX)))
320                 .thenReturn(true);
321 
322         assertTrue(mIwlanNetworkServiceProvider != null);
323 
324         // Set Network on and verify mCallback should receive onNetworkStateChanged.
325         mIwlanNetworkService.setNetworkConnected(true, IwlanNetworkService.Transport.WIFI);
326         verify(mCallback, timeout(1000).times(1)).onNetworkStateChanged();
327 
328         // Set Sub active and verify mCallback should receive onNetworkStateChanged.
329         mIwlanNetworkServiceProvider.subscriptionChanged();
330         verify(mCallback, timeout(1000).times(2)).onNetworkStateChanged();
331 
332         // Create expected NetworkRegistrationInfo
333         NetworkRegistrationInfo.Builder expectedStateBuilder =
334                 generateStateBuilder(
335                         domain, mIsSubActive, NetworkRegistrationInfo.REGISTRATION_STATE_HOME);
336 
337         mBinder.requestNetworkRegistrationInfo(0, domain, mCallback);
338 
339         verify(mCallback, timeout(1000).times(1))
340                 .onRequestNetworkRegistrationInfoComplete(
341                         eq(NetworkServiceCallback.RESULT_SUCCESS),
342                         eq(expectedStateBuilder.build()));
343 
344         IwlanNetworkService.setNetworkConnected(
345                 false, IwlanNetworkService.Transport.UNSPECIFIED_NETWORK);
346     }
347 
generateStateBuilder( int domain, boolean isSubActive, int registrationState)348     private NetworkRegistrationInfo.Builder generateStateBuilder(
349             int domain, boolean isSubActive, int registrationState) {
350         NetworkRegistrationInfo.Builder expectedStateBuilder =
351                 new NetworkRegistrationInfo.Builder();
352         expectedStateBuilder
353                 .setAccessNetworkTechnology(TelephonyManager.NETWORK_TYPE_IWLAN)
354                 .setAvailableServices(Arrays.asList(NetworkRegistrationInfo.SERVICE_TYPE_DATA))
355                 .setTransportType(AccessNetworkConstants.TRANSPORT_TYPE_WLAN)
356                 .setEmergencyOnly(!isSubActive)
357                 .setDomain(domain)
358                 .setRegistrationState(registrationState);
359 
360         return expectedStateBuilder;
361     }
362 }
363