Home | History | Annotate | Download | only in shadows 
      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