1 package org.robolectric.shadows; 2 3 import static android.os.Build.VERSION_CODES.KITKAT; 4 import static android.os.Build.VERSION_CODES.LOLLIPOP; 5 import static android.os.Build.VERSION_CODES.M; 6 import static android.os.Build.VERSION_CODES.N; 7 import static androidx.test.core.app.ApplicationProvider.getApplicationContext; 8 import static com.google.common.truth.Truth.assertThat; 9 import static org.mockito.Mockito.spy; 10 import static org.mockito.Mockito.times; 11 import static org.mockito.Mockito.verify; 12 import static org.robolectric.Shadows.shadowOf; 13 14 import android.content.Context; 15 import android.net.ConnectivityManager; 16 import android.net.LinkProperties; 17 import android.net.Network; 18 import android.net.NetworkCapabilities; 19 import android.net.NetworkInfo; 20 import android.net.NetworkRequest; 21 import android.provider.Settings; 22 import android.telephony.TelephonyManager; 23 import androidx.test.ext.junit.runners.AndroidJUnit4; 24 import java.util.Map; 25 import org.junit.Before; 26 import org.junit.Test; 27 import org.junit.runner.RunWith; 28 import org.robolectric.annotation.Config; 29 import org.robolectric.util.ReflectionHelpers; 30 import org.robolectric.util.ReflectionHelpers.ClassParameter; 31 32 @RunWith(AndroidJUnit4.class) 33 public class ShadowConnectivityManagerTest { 34 private ConnectivityManager connectivityManager; 35 private ShadowNetworkInfo shadowOfActiveNetworkInfo; 36 37 @Before 38 public void setUp() throws Exception { 39 connectivityManager = 40 (ConnectivityManager) 41 getApplicationContext().getSystemService(Context.CONNECTIVITY_SERVICE); 42 shadowOfActiveNetworkInfo = shadowOf(connectivityManager.getActiveNetworkInfo()); 43 } 44 45 @Test 46 public void getActiveNetworkInfo_shouldInitializeItself() { 47 assertThat(connectivityManager.getActiveNetworkInfo()).isNotNull(); 48 } 49 50 @Test 51 public void getActiveNetworkInfo_shouldReturnTrueCorrectly() { 52 shadowOfActiveNetworkInfo.setConnectionStatus(NetworkInfo.State.CONNECTED); 53 assertThat(connectivityManager.getActiveNetworkInfo().isConnectedOrConnecting()).isTrue(); 54 assertThat(connectivityManager.getActiveNetworkInfo().isConnected()).isTrue(); 55 56 shadowOfActiveNetworkInfo.setConnectionStatus(NetworkInfo.State.CONNECTING); 57 assertThat(connectivityManager.getActiveNetworkInfo().isConnectedOrConnecting()).isTrue(); 58 assertThat(connectivityManager.getActiveNetworkInfo().isConnected()).isFalse(); 59 60 shadowOfActiveNetworkInfo.setConnectionStatus(NetworkInfo.State.DISCONNECTED); 61 assertThat(connectivityManager.getActiveNetworkInfo().isConnectedOrConnecting()).isFalse(); 62 assertThat(connectivityManager.getActiveNetworkInfo().isConnected()).isFalse(); 63 } 64 65 @Test 66 public void getNetworkInfo_shouldReturnDefaultNetworks() throws Exception { 67 NetworkInfo wifi = connectivityManager.getNetworkInfo(ConnectivityManager.TYPE_WIFI); 68 assertThat(wifi.getDetailedState()).isEqualTo(NetworkInfo.DetailedState.DISCONNECTED); 69 70 NetworkInfo mobile = connectivityManager.getNetworkInfo(ConnectivityManager.TYPE_MOBILE); 71 assertThat(mobile.getDetailedState()).isEqualTo(NetworkInfo.DetailedState.CONNECTED); 72 } 73 74 @Test @Config(minSdk = LOLLIPOP) 75 public void getNetworkInfo_shouldReturnSomeForAllNetworks() throws Exception { 76 Network[] allNetworks = connectivityManager.getAllNetworks(); 77 for (Network network: allNetworks) { 78 NetworkInfo networkInfo = connectivityManager.getNetworkInfo(network); 79 assertThat(networkInfo).isNotNull(); 80 } 81 } 82 83 @Test @Config(minSdk = LOLLIPOP) 84 public void getNetworkInfo_shouldReturnAddedNetwork() throws Exception { 85 Network vpnNetwork = ShadowNetwork.newInstance(123); 86 NetworkInfo vpnNetworkInfo = 87 ShadowNetworkInfo.newInstance( 88 NetworkInfo.DetailedState.CONNECTED, 89 ConnectivityManager.TYPE_VPN, 90 0, 91 true, 92 NetworkInfo.State.CONNECTED); 93 shadowOf(connectivityManager).addNetwork(vpnNetwork, vpnNetworkInfo); 94 95 NetworkInfo returnedNetworkInfo = connectivityManager.getNetworkInfo(vpnNetwork); 96 assertThat(returnedNetworkInfo).isSameAs(vpnNetworkInfo); 97 } 98 99 @Test @Config(minSdk = LOLLIPOP) 100 public void getNetworkInfo_shouldNotReturnRemovedNetwork() throws Exception { 101 Network wifiNetwork = ShadowNetwork.newInstance(ShadowConnectivityManager.NET_ID_WIFI); 102 shadowOf(connectivityManager).removeNetwork(wifiNetwork); 103 104 NetworkInfo returnedNetworkInfo = connectivityManager.getNetworkInfo(wifiNetwork); 105 assertThat(returnedNetworkInfo).isNull(); 106 } 107 108 @Test 109 public void setConnectionType_shouldReturnTypeCorrectly() { 110 shadowOfActiveNetworkInfo.setConnectionType(ConnectivityManager.TYPE_MOBILE); 111 assertThat(shadowOfActiveNetworkInfo.getType()).isEqualTo(ConnectivityManager.TYPE_MOBILE); 112 113 shadowOfActiveNetworkInfo.setConnectionType(ConnectivityManager.TYPE_WIFI); 114 assertThat(shadowOfActiveNetworkInfo.getType()).isEqualTo(ConnectivityManager.TYPE_WIFI); 115 } 116 117 @Test 118 public void shouldGetAndSetBackgroundDataSetting() throws Exception { 119 assertThat(connectivityManager.getBackgroundDataSetting()).isFalse(); 120 shadowOf(connectivityManager).setBackgroundDataSetting(true); 121 assertThat(connectivityManager.getBackgroundDataSetting()).isTrue(); 122 } 123 124 @Test 125 public void setActiveNetworkInfo_shouldSetActiveNetworkInfo() throws Exception { 126 shadowOf(connectivityManager).setActiveNetworkInfo(null); 127 assertThat(connectivityManager.getActiveNetworkInfo()).isNull(); 128 shadowOf(connectivityManager) 129 .setActiveNetworkInfo( 130 ShadowNetworkInfo.newInstance( 131 null, 132 ConnectivityManager.TYPE_MOBILE_HIPRI, 133 TelephonyManager.NETWORK_TYPE_EDGE, 134 true, 135 NetworkInfo.State.DISCONNECTED)); 136 137 NetworkInfo info = connectivityManager.getActiveNetworkInfo(); 138 139 assertThat(info.getType()).isEqualTo(ConnectivityManager.TYPE_MOBILE_HIPRI); 140 assertThat(info.getSubtype()).isEqualTo(TelephonyManager.NETWORK_TYPE_EDGE); 141 assertThat(info.isAvailable()).isTrue(); 142 assertThat(info.isConnected()).isFalse(); 143 } 144 145 @Test 146 @Config(minSdk = M) 147 public void getActiveNetwork_shouldInitializeItself() { 148 assertThat(connectivityManager.getActiveNetwork()).isNotNull(); 149 } 150 151 @Test 152 @Config(minSdk = M) 153 public void getActiveNetwork_nullIfNetworkNotActive() { 154 shadowOf(connectivityManager).setDefaultNetworkActive(false); 155 assertThat(connectivityManager.getActiveNetwork()).isNull(); 156 } 157 158 @Test 159 @Config(minSdk = M) 160 public void setActiveNetworkInfo_shouldSetActiveNetwork() throws Exception { 161 shadowOf(connectivityManager).setActiveNetworkInfo(null); 162 assertThat(connectivityManager.getActiveNetworkInfo()).isNull(); 163 shadowOf(connectivityManager) 164 .setActiveNetworkInfo( 165 ShadowNetworkInfo.newInstance( 166 null, 167 ConnectivityManager.TYPE_MOBILE_HIPRI, 168 TelephonyManager.NETWORK_TYPE_EDGE, 169 true, 170 NetworkInfo.State.DISCONNECTED)); 171 172 NetworkInfo info = connectivityManager.getActiveNetworkInfo(); 173 174 assertThat(info.getType()).isEqualTo(ConnectivityManager.TYPE_MOBILE_HIPRI); 175 assertThat(info.getSubtype()).isEqualTo(TelephonyManager.NETWORK_TYPE_EDGE); 176 assertThat(info.isAvailable()).isTrue(); 177 assertThat(info.isConnected()).isFalse(); 178 assertThat(shadowOf(connectivityManager.getActiveNetwork()).getNetId()).isEqualTo(info.getType()); 179 } 180 181 @Test 182 public void getAllNetworkInfo_shouldReturnAllNetworkInterfaces() throws Exception { 183 NetworkInfo[] infos = connectivityManager.getAllNetworkInfo(); 184 assertThat(infos).asList().hasSize(2); 185 assertThat(infos).asList().contains(connectivityManager.getActiveNetworkInfo()); 186 187 shadowOf(connectivityManager).setActiveNetworkInfo(null); 188 assertThat(connectivityManager.getAllNetworkInfo()).isEmpty(); 189 } 190 191 @Test 192 @Config(minSdk = LOLLIPOP) 193 public void getAllNetworkInfo_shouldEqualGetAllNetworks() throws Exception { 194 // Update the active network so that we're no longer in the default state. 195 NetworkInfo networkInfo = 196 ShadowNetworkInfo.newInstance( 197 NetworkInfo.DetailedState.CONNECTED, 198 ConnectivityManager.TYPE_WIFI, 199 0 /* subType */, 200 true /* isAvailable */, 201 true /* isConnected */); 202 shadowOf(connectivityManager).setActiveNetworkInfo(networkInfo); 203 204 // Verify that getAllNetworks and getAllNetworkInfo match. 205 Network[] networks = connectivityManager.getAllNetworks(); 206 NetworkInfo[] networkInfos = new NetworkInfo[networks.length]; 207 for (int i = 0; i < networks.length; i++) { 208 networkInfos[i] = connectivityManager.getNetworkInfo(networks[i]); 209 assertThat(connectivityManager.getAllNetworkInfo()).asList().contains(networkInfos[i]); 210 } 211 assertThat(networkInfos).hasLength(connectivityManager.getAllNetworkInfo().length); 212 } 213 214 @Test 215 @Config(minSdk = LOLLIPOP) 216 public void getAllNetworkInfo_nullIfNetworkNotActive() { 217 shadowOf(connectivityManager).setDefaultNetworkActive(false); 218 assertThat(connectivityManager.getAllNetworkInfo()).isNull(); 219 } 220 221 @Test @Config(minSdk = LOLLIPOP) 222 public void getAllNetworks_shouldReturnAllNetworks() throws Exception { 223 Network[] networks = connectivityManager.getAllNetworks(); 224 assertThat(networks).asList().hasSize(2); 225 } 226 227 @Test @Config(minSdk = LOLLIPOP) 228 public void getAllNetworks_shouldReturnNoNetworksWhenCleared() throws Exception { 229 shadowOf(connectivityManager).clearAllNetworks(); 230 Network[] networks = connectivityManager.getAllNetworks(); 231 assertThat(networks).isEmpty(); 232 } 233 234 @Test @Config(minSdk = LOLLIPOP) 235 public void getAllNetworks_shouldReturnAddedNetworks() throws Exception { 236 // Let's start clear. 237 shadowOf(connectivityManager).clearAllNetworks(); 238 239 // Add a "VPN network". 240 Network vpnNetwork = ShadowNetwork.newInstance(123); 241 NetworkInfo vpnNetworkInfo = 242 ShadowNetworkInfo.newInstance( 243 NetworkInfo.DetailedState.CONNECTED, 244 ConnectivityManager.TYPE_VPN, 245 0, 246 true, 247 NetworkInfo.State.CONNECTED); 248 shadowOf(connectivityManager).addNetwork(vpnNetwork, vpnNetworkInfo); 249 250 Network[] networks = connectivityManager.getAllNetworks(); 251 assertThat(networks).asList().hasSize(1); 252 253 Network returnedNetwork = networks[0]; 254 assertThat(returnedNetwork).isSameAs(vpnNetwork); 255 256 NetworkInfo returnedNetworkInfo = connectivityManager.getNetworkInfo(returnedNetwork); 257 assertThat(returnedNetworkInfo).isSameAs(vpnNetworkInfo); 258 } 259 260 @Test @Config(minSdk = LOLLIPOP) 261 public void getAllNetworks_shouldNotReturnRemovedNetworks() throws Exception { 262 Network wifiNetwork = ShadowNetwork.newInstance(ShadowConnectivityManager.NET_ID_WIFI); 263 shadowOf(connectivityManager).removeNetwork(wifiNetwork); 264 265 Network[] networks = connectivityManager.getAllNetworks(); 266 assertThat(networks).asList().hasSize(1); 267 268 Network returnedNetwork = networks[0]; 269 ShadowNetwork shadowReturnedNetwork = shadowOf(returnedNetwork); 270 assertThat(shadowReturnedNetwork.getNetId()).isNotEqualTo(ShadowConnectivityManager.NET_ID_WIFI); 271 } 272 273 @Test 274 public void getNetworkPreference_shouldGetDefaultValue() throws Exception { 275 assertThat(connectivityManager.getNetworkPreference()).isEqualTo(ConnectivityManager.DEFAULT_NETWORK_PREFERENCE); 276 } 277 278 @Test 279 @Config(minSdk = M) 280 public void getReportedNetworkConnectivity() throws Exception { 281 Network wifiNetwork = ShadowNetwork.newInstance(ShadowConnectivityManager.NET_ID_WIFI); 282 connectivityManager.reportNetworkConnectivity(wifiNetwork, true); 283 284 Map<Network, Boolean> reportedNetworks = 285 shadowOf(connectivityManager).getReportedNetworkConnectivity(); 286 assertThat(reportedNetworks.size()).isEqualTo(1); 287 assertThat(reportedNetworks.get(wifiNetwork)).isTrue(); 288 289 // Update the status. 290 connectivityManager.reportNetworkConnectivity(wifiNetwork, false); 291 reportedNetworks = shadowOf(connectivityManager).getReportedNetworkConnectivity(); 292 assertThat(reportedNetworks.size()).isEqualTo(1); 293 assertThat(reportedNetworks.get(wifiNetwork)).isFalse(); 294 } 295 296 @Test 297 public void setNetworkPreference_shouldSetDefaultValue() throws Exception { 298 connectivityManager.setNetworkPreference(ConnectivityManager.TYPE_MOBILE); 299 assertThat(connectivityManager.getNetworkPreference()).isEqualTo(connectivityManager.getNetworkPreference()); 300 connectivityManager.setNetworkPreference(ConnectivityManager.TYPE_WIFI); 301 assertThat(connectivityManager.getNetworkPreference()).isEqualTo(ConnectivityManager.TYPE_WIFI); 302 } 303 304 @Test @Config(minSdk = LOLLIPOP) 305 public void getNetworkCallbacks_shouldHaveEmptyDefault() throws Exception { 306 assertThat(shadowOf(connectivityManager).getNetworkCallbacks()).isEmpty(); 307 } 308 309 private static ConnectivityManager.NetworkCallback createSimpleCallback() { 310 return new ConnectivityManager.NetworkCallback() { 311 @Override 312 public void onAvailable(Network network) {} 313 @Override 314 public void onLost(Network network) {} 315 }; 316 } 317 318 @Test 319 @Config(minSdk = LOLLIPOP) 320 public void requestNetwork_shouldAddCallback() throws Exception { 321 NetworkRequest.Builder builder = new NetworkRequest.Builder(); 322 ConnectivityManager.NetworkCallback callback = createSimpleCallback(); 323 connectivityManager.requestNetwork(builder.build(), callback); 324 assertThat(shadowOf(connectivityManager).getNetworkCallbacks()).hasSize(1); 325 } 326 327 @Test @Config(minSdk = LOLLIPOP) 328 public void registerCallback_shouldAddCallback() throws Exception { 329 NetworkRequest.Builder builder = new NetworkRequest.Builder(); 330 ConnectivityManager.NetworkCallback callback = createSimpleCallback(); 331 connectivityManager.registerNetworkCallback(builder.build(), callback); 332 assertThat(shadowOf(connectivityManager).getNetworkCallbacks()).hasSize(1); 333 } 334 335 @Test @Config(minSdk = LOLLIPOP) 336 public void unregisterCallback_shouldRemoveCallbacks() throws Exception { 337 NetworkRequest.Builder builder = new NetworkRequest.Builder(); 338 // Add two different callbacks. 339 ConnectivityManager.NetworkCallback callback1 = createSimpleCallback(); 340 ConnectivityManager.NetworkCallback callback2 = createSimpleCallback(); 341 connectivityManager.registerNetworkCallback(builder.build(), callback1); 342 connectivityManager.registerNetworkCallback(builder.build(), callback2); 343 // Remove one at the time. 344 assertThat(shadowOf(connectivityManager).getNetworkCallbacks()).hasSize(2); 345 connectivityManager.unregisterNetworkCallback(callback2); 346 assertThat(shadowOf(connectivityManager).getNetworkCallbacks()).hasSize(1); 347 connectivityManager.unregisterNetworkCallback(callback1); 348 assertThat(shadowOf(connectivityManager).getNetworkCallbacks()).isEmpty(); 349 } 350 351 @Test(expected=IllegalArgumentException.class) @Config(minSdk = LOLLIPOP) 352 public void unregisterCallback_shouldNotAllowNullCallback() throws Exception { 353 // Verify that exception is thrown. 354 connectivityManager.unregisterNetworkCallback((ConnectivityManager.NetworkCallback) null); 355 } 356 357 @Test 358 public void isActiveNetworkMetered_defaultsToTrue() { 359 assertThat(connectivityManager.isActiveNetworkMetered()).isTrue(); 360 } 361 362 @Test 363 public void isActiveNetworkMetered_mobileIsMetered() { 364 shadowOf(connectivityManager) 365 .setActiveNetworkInfo(connectivityManager.getNetworkInfo(ConnectivityManager.TYPE_MOBILE)); 366 assertThat(connectivityManager.isActiveNetworkMetered()).isTrue(); 367 } 368 369 @Test 370 public void isActiveNetworkMetered_nonMobileIsUnmetered() { 371 shadowOf(connectivityManager) 372 .setActiveNetworkInfo(connectivityManager.getNetworkInfo(ConnectivityManager.TYPE_WIFI)); 373 assertThat(connectivityManager.isActiveNetworkMetered()).isFalse(); 374 } 375 376 @Test 377 public void isActiveNetworkMetered_noActiveNetwork() { 378 shadowOf(connectivityManager).setActiveNetworkInfo(null); 379 assertThat(connectivityManager.isActiveNetworkMetered()).isFalse(); 380 } 381 382 @Test 383 public void isActiveNetworkMetered_noDefaultNetworkActive() { 384 shadowOf(connectivityManager).setDefaultNetworkActive(false); 385 assertThat(connectivityManager.isActiveNetworkMetered()).isFalse(); 386 } 387 388 @Test 389 @Config(minSdk = M) 390 public void bindProcessToNetwork_shouldGetBoundNetworkForProcess() { 391 Network network = ShadowNetwork.newInstance(789); 392 connectivityManager.bindProcessToNetwork(network); 393 assertThat(connectivityManager.getBoundNetworkForProcess()).isSameAs(network); 394 } 395 396 @Test 397 @Config(minSdk = LOLLIPOP) 398 public void isDefaultNetworkActive_defaultActive() { 399 assertThat(shadowOf(connectivityManager).isDefaultNetworkActive()).isTrue(); 400 } 401 402 @Test 403 @Config(minSdk = LOLLIPOP) 404 public void isDefaultNetworkActive_notActive() { 405 shadowOf(connectivityManager).setDefaultNetworkActive(false); 406 assertThat(shadowOf(connectivityManager).isDefaultNetworkActive()).isFalse(); 407 } 408 409 private static ConnectivityManager.OnNetworkActiveListener createSimpleOnNetworkActiveListener() { 410 return new ConnectivityManager.OnNetworkActiveListener() { 411 @Override 412 public void onNetworkActive() {} 413 }; 414 } 415 416 @Test 417 @Config(minSdk = LOLLIPOP) 418 public void addDefaultNetworkActiveListener_shouldAddListener() throws Exception { 419 ConnectivityManager.OnNetworkActiveListener listener1 = 420 spy(createSimpleOnNetworkActiveListener()); 421 ConnectivityManager.OnNetworkActiveListener listener2 = 422 spy(createSimpleOnNetworkActiveListener()); 423 connectivityManager.addDefaultNetworkActiveListener(listener1); 424 connectivityManager.addDefaultNetworkActiveListener(listener2); 425 426 shadowOf(connectivityManager).setDefaultNetworkActive(true); 427 428 verify(listener1).onNetworkActive(); 429 verify(listener2).onNetworkActive(); 430 } 431 432 @Test 433 @Config(minSdk = LOLLIPOP) 434 public void removeDefaultNetworkActiveListener_shouldRemoveListeners() throws Exception { 435 // Add two different callbacks. 436 ConnectivityManager.OnNetworkActiveListener listener1 = 437 spy(createSimpleOnNetworkActiveListener()); 438 ConnectivityManager.OnNetworkActiveListener listener2 = 439 spy(createSimpleOnNetworkActiveListener()); 440 connectivityManager.addDefaultNetworkActiveListener(listener1); 441 connectivityManager.addDefaultNetworkActiveListener(listener2); 442 443 shadowOf(connectivityManager).setDefaultNetworkActive(true); 444 445 verify(listener1).onNetworkActive(); 446 verify(listener2).onNetworkActive(); 447 // Remove one at the time. 448 connectivityManager.removeDefaultNetworkActiveListener(listener2); 449 450 shadowOf(connectivityManager).setDefaultNetworkActive(true); 451 452 verify(listener1, times(2)).onNetworkActive(); 453 verify(listener2).onNetworkActive(); 454 455 connectivityManager.removeDefaultNetworkActiveListener(listener1); 456 457 shadowOf(connectivityManager).setDefaultNetworkActive(true); 458 459 verify(listener1, times(2)).onNetworkActive(); 460 verify(listener2).onNetworkActive(); 461 } 462 463 @Test(expected = IllegalArgumentException.class) 464 @Config(minSdk = LOLLIPOP) 465 public void removeDefaultNetworkActiveListener_shouldNotAllowNullListener() throws Exception { 466 // Verify that exception is thrown. 467 connectivityManager.removeDefaultNetworkActiveListener(null); 468 } 469 470 @Test 471 @Config(minSdk = LOLLIPOP) 472 public void getNetworkCapabilities() throws Exception { 473 NetworkCapabilities nc = new NetworkCapabilities(null); 474 ReflectionHelpers.callInstanceMethod( 475 nc, 476 "addCapability", 477 ClassParameter.from(int.class, NetworkCapabilities.NET_CAPABILITY_MMS)); 478 479 shadowOf(connectivityManager).setNetworkCapabilities( 480 shadowOf(connectivityManager).getActiveNetwork(), nc); 481 482 assertThat( 483 shadowOf(connectivityManager) 484 .getNetworkCapabilities(shadowOf(connectivityManager).getActiveNetwork()) 485 .hasCapability(NetworkCapabilities.NET_CAPABILITY_MMS)) 486 .isTrue(); 487 } 488 489 @Test 490 @Config(minSdk = N) 491 public void getCaptivePortalServerUrl_shouldReturnAddedUrl() { 492 assertThat(connectivityManager.getCaptivePortalServerUrl()).isEqualTo("http://10.0.0.2"); 493 494 shadowOf(connectivityManager).setCaptivePortalServerUrl("http://10.0.0.1"); 495 assertThat(connectivityManager.getCaptivePortalServerUrl()).isEqualTo("http://10.0.0.1"); 496 497 shadowOf(connectivityManager).setCaptivePortalServerUrl("http://10.0.0.2"); 498 assertThat(connectivityManager.getCaptivePortalServerUrl()).isEqualTo("http://10.0.0.2"); 499 } 500 501 @Test 502 @Config(minSdk = KITKAT) 503 public void setAirplaneMode() { 504 connectivityManager.setAirplaneMode(false); 505 assertThat( 506 Settings.Global.getInt( 507 getApplicationContext().getContentResolver(), Settings.Global.AIRPLANE_MODE_ON, -1)) 508 .isEqualTo(0); 509 connectivityManager.setAirplaneMode(true); 510 assertThat( 511 Settings.Global.getInt( 512 getApplicationContext().getContentResolver(), Settings.Global.AIRPLANE_MODE_ON, -1)) 513 .isEqualTo(1); 514 } 515 516 @Test 517 @Config(minSdk = LOLLIPOP) 518 public void getLinkProperties() { 519 Network network = shadowOf(connectivityManager).getActiveNetwork(); 520 LinkProperties lp = ReflectionHelpers.callConstructor(LinkProperties.class); 521 shadowOf(connectivityManager).setLinkProperties(network, lp); 522 523 assertThat(connectivityManager.getLinkProperties(network)).isEqualTo(lp); 524 } 525 526 @Test 527 @Config(minSdk = LOLLIPOP) 528 public void getLinkProperties_shouldReturnNull() { 529 Network network = shadowOf(connectivityManager).getActiveNetwork(); 530 shadowOf(connectivityManager).setLinkProperties(network, null); 531 532 assertThat(connectivityManager.getLinkProperties(network)).isNull(); 533 } 534 } 535