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