1package com.xtremelabs.robolectric.shadows; 2 3import android.net.wifi.ScanResult; 4import android.net.wifi.WifiConfiguration; 5import android.net.wifi.WifiInfo; 6import android.net.wifi.WifiManager; 7import android.util.Pair; 8import com.xtremelabs.robolectric.WithTestDefaultsRunner; 9import org.junit.Before; 10import org.junit.Test; 11import org.junit.runner.RunWith; 12 13import java.security.InvalidParameterException; 14import java.util.ArrayList; 15import java.util.List; 16 17import static android.content.Context.WIFI_SERVICE; 18import static com.xtremelabs.robolectric.Robolectric.application; 19import static com.xtremelabs.robolectric.Robolectric.shadowOf; 20import static junit.framework.Assert.assertTrue; 21import static org.hamcrest.CoreMatchers.equalTo; 22import static org.hamcrest.CoreMatchers.not; 23import static org.hamcrest.CoreMatchers.sameInstance; 24import static org.junit.Assert.assertEquals; 25import static org.junit.Assert.assertFalse; 26import static org.junit.Assert.assertNotNull; 27import static org.junit.Assert.assertThat; 28 29@RunWith(WithTestDefaultsRunner.class) 30public class WifiManagerTest { 31 32 private WifiManager wifiManager; 33 private ShadowWifiManager shadowWifiManager; 34 35 @Before 36 public void setUp() throws Exception { 37 wifiManager = (WifiManager) application.getSystemService(WIFI_SERVICE); 38 shadowWifiManager = shadowOf(wifiManager); 39 } 40 41 @Test 42 public void shouldReturnWifiInfo() { 43 assertEquals(wifiManager.getConnectionInfo().getClass(), WifiInfo.class); 44 } 45 46 @Test(expected = SecurityException.class) 47 public void setWifiEnabled_shouldThrowSecurityExceptionWhenAccessWifiStatePermissionNotGranted() throws Exception { 48 shadowWifiManager.setAccessWifiStatePermission(false); 49 wifiManager.setWifiEnabled(true); 50 } 51 52 @Test(expected = SecurityException.class) 53 public void isWifiEnabled_shouldThrowSecurityExceptionWhenAccessWifiStatePermissionNotGranted() throws Exception { 54 shadowWifiManager.setAccessWifiStatePermission(false); 55 wifiManager.isWifiEnabled(); 56 } 57 58 @Test(expected = SecurityException.class) 59 public void getConnectionInfo_shouldThrowSecurityExceptionWhenAccessWifiStatePermissionNotGranted() throws Exception { 60 shadowWifiManager.setAccessWifiStatePermission(false); 61 wifiManager.getConnectionInfo(); 62 } 63 64 @Test 65 public void shouldEnableNetworks() throws Exception { 66 int networkId = 666; 67 wifiManager.enableNetwork(networkId, true); 68 Pair<Integer, Boolean> lastEnabled = shadowWifiManager.getLastEnabledNetwork(); 69 assertThat(lastEnabled, equalTo(new Pair<Integer, Boolean>(666, true))); 70 71 int anotherNetworkId = 777; 72 wifiManager.enableNetwork(anotherNetworkId, false); 73 lastEnabled = shadowWifiManager.getLastEnabledNetwork(); 74 assertThat(lastEnabled, equalTo(new Pair<Integer, Boolean>(777, false))); 75 } 76 77 @Test 78 public void shouldReturnSetScanResults() throws Exception { 79 List<ScanResult> scanResults = new ArrayList<ScanResult>(); 80 shadowWifiManager.setScanResults(scanResults); 81 assertThat(wifiManager.getScanResults(), sameInstance(scanResults)); 82 } 83 84 @Test 85 public void shouldRecordTheLastAddedNetwork() throws Exception { 86 WifiConfiguration wifiConfiguration = new WifiConfiguration(); 87 wifiConfiguration.networkId = -1; 88 int networkId = wifiManager.addNetwork(wifiConfiguration); 89 assertThat(networkId, equalTo(0)); 90 assertThat(wifiManager.getConfiguredNetworks().get(0), not(sameInstance(wifiConfiguration))); 91 assertThat(wifiConfiguration.networkId, equalTo(-1)); 92 assertThat(wifiManager.getConfiguredNetworks().get(0).networkId, equalTo(0)); 93 94 WifiConfiguration anotherConfig = new WifiConfiguration(); 95 assertThat(wifiManager.addNetwork(anotherConfig), equalTo(1)); 96 assertThat(anotherConfig.networkId, equalTo(-1)); 97 assertThat(wifiManager.getConfiguredNetworks().get(1).networkId, equalTo(1)); 98 } 99 100 @Test 101 public void updateNetwork_shouldReplaceNetworks() throws Exception { 102 WifiConfiguration wifiConfiguration = new WifiConfiguration(); 103 wifiConfiguration.networkId = -1; 104 wifiManager.addNetwork(wifiConfiguration); 105 106 WifiConfiguration anotherConfig = new WifiConfiguration(); 107 int networkId = wifiManager.addNetwork(anotherConfig); 108 109 assertThat(networkId, equalTo(1)); 110 WifiConfiguration configuration = new WifiConfiguration(); 111 configuration.networkId = networkId; 112 configuration.priority = 44; 113 114 assertThat(wifiManager.updateNetwork(configuration), equalTo(networkId)); 115 List<WifiConfiguration> configuredNetworks = wifiManager.getConfiguredNetworks(); 116 assertThat(configuredNetworks.size(), equalTo(2)); 117 assertThat(configuration.priority, equalTo(44)); 118 assertThat(configuredNetworks.get(1).priority, equalTo(44)); 119 } 120 121 @Test 122 public void updateNetwork_shouldRejectNullandNewConfigs() throws Exception { 123 WifiConfiguration config = new WifiConfiguration(); 124 config.networkId = -1; 125 assertThat(wifiManager.updateNetwork(config), equalTo(-1)); 126 assertThat(wifiManager.updateNetwork(null), equalTo(-1)); 127 assertTrue(wifiManager.getConfiguredNetworks().isEmpty()); 128 } 129 130 @Test 131 public void shouldSaveConfigurations() throws Exception { 132 shadowWifiManager.wasSaved = false; 133 assertThat(wifiManager.saveConfiguration(), equalTo(true)); 134 assertThat(shadowWifiManager.wasSaved, equalTo(true)); 135 } 136 137 @Test 138 public void shouldCreateWifiLock() throws Exception { 139 assertNotNull(wifiManager.createWifiLock("TAG")); 140 assertNotNull(wifiManager.createWifiLock(1, "TAG")); 141 } 142 143 @Test 144 public void shouldAcquireAndReleaseWifilockRefCounted() throws Exception { 145 WifiManager.WifiLock lock = wifiManager.createWifiLock("TAG"); 146 lock.acquire(); 147 lock.acquire(); 148 assertTrue(lock.isHeld()); 149 lock.release(); 150 assertTrue(lock.isHeld()); 151 lock.release(); 152 assertFalse(lock.isHeld()); 153 } 154 155 @Test 156 public void shouldAcquireAndReleaseWifilockNonRefCounted() throws Exception { 157 WifiManager.WifiLock lock = wifiManager.createWifiLock("TAG"); 158 lock.setReferenceCounted(false); 159 lock.acquire(); 160 assertTrue(lock.isHeld()); 161 lock.acquire(); 162 assertTrue(lock.isHeld()); 163 lock.release(); 164 assertFalse(lock.isHeld()); 165 } 166 167 @Test(expected = RuntimeException.class) 168 public void shouldThrowRuntimeExceptionIfLockisUnderlocked() throws Exception { 169 WifiManager.WifiLock lock = wifiManager.createWifiLock("TAG"); 170 lock.release(); 171 } 172 173 @Test(expected = UnsupportedOperationException.class) 174 public void shouldThrowUnsupportedOperationIfLockisOverlocked() throws Exception { 175 WifiManager.WifiLock lock = wifiManager.createWifiLock("TAG"); 176 for (int i=0; i<ShadowWifiManager.ShadowWifiLock.MAX_ACTIVE_LOCKS; i++) lock.acquire(); 177 } 178 179 @Test 180 public void shouldCalculateSignalLevelSetBefore() { 181 ShadowWifiManager.setSignalLevelInPercent(0.5f); 182 assertEquals(2, WifiManager.calculateSignalLevel(0, 5)); 183 assertEquals(2, WifiManager.calculateSignalLevel(2, 5)); 184 185 ShadowWifiManager.setSignalLevelInPercent(0.9f); 186 assertEquals(3, WifiManager.calculateSignalLevel(0, 5)); 187 assertEquals(3, WifiManager.calculateSignalLevel(2, 5)); 188 189 ShadowWifiManager.setSignalLevelInPercent(1f); 190 assertEquals(3, WifiManager.calculateSignalLevel(0, 4)); 191 assertEquals(3, WifiManager.calculateSignalLevel(2, 4)); 192 193 ShadowWifiManager.setSignalLevelInPercent(0); 194 assertEquals(0, WifiManager.calculateSignalLevel(0, 5)); 195 assertEquals(0, WifiManager.calculateSignalLevel(2, 5)); 196 } 197 198 @Test(expected = IllegalArgumentException.class) 199 public void shouldThrowIllegalArgumentExceptionWhenSignalLevelToLow() { 200 ShadowWifiManager.setSignalLevelInPercent(-0.01f); 201 } 202 203 @Test(expected = IllegalArgumentException.class) 204 public void shouldThrowIllegalArgumentExceptionWhenSignalLevelToHigh() { 205 ShadowWifiManager.setSignalLevelInPercent(1.01f); 206 } 207} 208