diff options
Diffstat (limited to 'wifi/tests/src')
20 files changed, 1012 insertions, 144 deletions
diff --git a/wifi/tests/src/android/net/wifi/ParcelUtilTest.java b/wifi/tests/src/android/net/wifi/ParcelUtilTest.java index 6787594b829c..0c3bf3b9ef2e 100644 --- a/wifi/tests/src/android/net/wifi/ParcelUtilTest.java +++ b/wifi/tests/src/android/net/wifi/ParcelUtilTest.java @@ -22,7 +22,7 @@ import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertNull; import android.os.Parcel; -import android.test.suitebuilder.annotation.SmallTest; +import android.support.test.filters.SmallTest; import org.junit.Before; import org.junit.Test; diff --git a/wifi/tests/src/android/net/wifi/ScanResultTest.java b/wifi/tests/src/android/net/wifi/ScanResultTest.java new file mode 100644 index 000000000000..458c43dcd692 --- /dev/null +++ b/wifi/tests/src/android/net/wifi/ScanResultTest.java @@ -0,0 +1,193 @@ +/* + * Copyright (C) 2018 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package android.net.wifi; + +import static org.junit.Assert.assertArrayEquals; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNull; +import static org.mockito.Mockito.validateMockitoUsage; + +import android.os.Parcel; +import android.support.test.filters.SmallTest; +import android.net.wifi.WifiScanner.ScanSettings; + +import org.junit.After; +import org.junit.Before; +import org.junit.Test; +import org.mockito.MockitoAnnotations; + + +/** + * Unit tests for {@link android.net.wifi.WifiScanner}. + */ +@SmallTest +public class ScanResultTest { + public static final String TEST_SSID = "\"test_ssid\""; + public static final String TEST_BSSID = "04:ac:fe:45:34:10"; + public static final String TEST_CAPS = "CCMP"; + public static final int TEST_LEVEL = -56; + public static final int TEST_FREQUENCY = 2412; + public static final long TEST_TSF = 04660l; + + /** + * Setup before tests. + */ + @Before + public void setUp() throws Exception { + MockitoAnnotations.initMocks(this); + } + + /** + * Clean up after tests. + */ + @After + public void cleanup() { + validateMockitoUsage(); + } + + /** + * Verify parcel read/write for ScanResult. + */ + @Test + public void verifyScanResultParcelWithoutRadioChainInfo() throws Exception { + ScanResult writeScanResult = createScanResult(); + ScanResult readScanResult = parcelReadWrite(writeScanResult); + assertScanResultEquals(writeScanResult, readScanResult); + } + + /** + * Verify parcel read/write for ScanResult. + */ + @Test + public void verifyScanResultParcelWithZeroRadioChainInfo() throws Exception { + ScanResult writeScanResult = createScanResult(); + writeScanResult.radioChainInfos = new ScanResult.RadioChainInfo[0]; + ScanResult readScanResult = parcelReadWrite(writeScanResult); + assertNull(readScanResult.radioChainInfos); + } + + /** + * Verify parcel read/write for ScanResult. + */ + @Test + public void verifyScanResultParcelWithRadioChainInfo() throws Exception { + ScanResult writeScanResult = createScanResult(); + writeScanResult.radioChainInfos = new ScanResult.RadioChainInfo[2]; + writeScanResult.radioChainInfos[0] = new ScanResult.RadioChainInfo(); + writeScanResult.radioChainInfos[0].id = 0; + writeScanResult.radioChainInfos[0].level = -45; + writeScanResult.radioChainInfos[1] = new ScanResult.RadioChainInfo(); + writeScanResult.radioChainInfos[1].id = 1; + writeScanResult.radioChainInfos[1].level = -54; + ScanResult readScanResult = parcelReadWrite(writeScanResult); + assertScanResultEquals(writeScanResult, readScanResult); + } + + /** + * Verify copy constructor for ScanResult. + */ + @Test + public void verifyScanResultCopyWithoutRadioChainInfo() throws Exception { + ScanResult scanResult = createScanResult(); + ScanResult copyScanResult = new ScanResult(scanResult); + assertScanResultEquals(scanResult, copyScanResult); + } + + /** + * Verify copy constructor for ScanResult. + */ + @Test + public void verifyScanResultCopyWithRadioChainInfo() throws Exception { + ScanResult scanResult = createScanResult(); + scanResult.radioChainInfos = new ScanResult.RadioChainInfo[2]; + scanResult.radioChainInfos[0] = new ScanResult.RadioChainInfo(); + scanResult.radioChainInfos[0].id = 0; + scanResult.radioChainInfos[0].level = -45; + scanResult.radioChainInfos[1] = new ScanResult.RadioChainInfo(); + scanResult.radioChainInfos[1].id = 1; + scanResult.radioChainInfos[1].level = -54; + ScanResult copyScanResult = new ScanResult(scanResult); + assertScanResultEquals(scanResult, copyScanResult); + } + + /** + * Verify toString for ScanResult. + */ + @Test + public void verifyScanResultToStringWithoutRadioChainInfo() throws Exception { + ScanResult scanResult = createScanResult(); + assertEquals("SSID: \"test_ssid\", BSSID: 04:ac:fe:45:34:10, capabilities: CCMP, " + + "level: -56, frequency: 2412, timestamp: 2480, distance: 0(cm), distanceSd: 0(cm), " + + "passpoint: no, ChannelBandwidth: 0, centerFreq0: 0, centerFreq1: 0, " + + "80211mcResponder: is not supported, Carrier AP: no, " + + "Carrier AP EAP Type: 0, Carrier name: null, " + + "Radio Chain Infos: null", scanResult.toString()); + } + + /** + * Verify toString for ScanResult. + */ + @Test + public void verifyScanResultToStringWithRadioChainInfo() throws Exception { + ScanResult scanResult = createScanResult(); + scanResult.radioChainInfos = new ScanResult.RadioChainInfo[2]; + scanResult.radioChainInfos[0] = new ScanResult.RadioChainInfo(); + scanResult.radioChainInfos[0].id = 0; + scanResult.radioChainInfos[0].level = -45; + scanResult.radioChainInfos[1] = new ScanResult.RadioChainInfo(); + scanResult.radioChainInfos[1].id = 1; + scanResult.radioChainInfos[1].level = -54; + assertEquals("SSID: \"test_ssid\", BSSID: 04:ac:fe:45:34:10, capabilities: CCMP, " + + "level: -56, frequency: 2412, timestamp: 2480, distance: 0(cm), distanceSd: 0(cm), " + + "passpoint: no, ChannelBandwidth: 0, centerFreq0: 0, centerFreq1: 0, " + + "80211mcResponder: is not supported, Carrier AP: no, " + + "Carrier AP EAP Type: 0, Carrier name: null, " + + "Radio Chain Infos: [RadioChainInfo: id=0, level=-45, " + + "RadioChainInfo: id=1, level=-54]", scanResult.toString()); + } + + /** + * Write the provided {@link ScanResult} to a parcel and deserialize it. + */ + private static ScanResult parcelReadWrite(ScanResult writeResult) throws Exception { + Parcel parcel = Parcel.obtain(); + writeResult.writeToParcel(parcel, 0); + parcel.setDataPosition(0); // Rewind data position back to the beginning for read. + return ScanResult.CREATOR.createFromParcel(parcel); + } + + private static ScanResult createScanResult() { + ScanResult result = new ScanResult(); + result.wifiSsid = WifiSsid.createFromAsciiEncoded(TEST_SSID); + result.BSSID = TEST_BSSID; + result.capabilities = TEST_CAPS; + result.level = TEST_LEVEL; + result.frequency = TEST_FREQUENCY; + result.timestamp = TEST_TSF; + return result; + } + + private static void assertScanResultEquals(ScanResult expected, ScanResult actual) { + assertEquals(expected.SSID, actual.SSID); + assertEquals(expected.BSSID, actual.BSSID); + assertEquals(expected.capabilities, actual.capabilities); + assertEquals(expected.level, actual.level); + assertEquals(expected.frequency, actual.frequency); + assertEquals(expected.timestamp, actual.timestamp); + assertArrayEquals(expected.radioChainInfos, actual.radioChainInfos); + } +} diff --git a/wifi/tests/src/android/net/wifi/WifiConfigurationTest.java b/wifi/tests/src/android/net/wifi/WifiConfigurationTest.java index 622dce6edbd9..8a3a7f5a2d79 100644 --- a/wifi/tests/src/android/net/wifi/WifiConfigurationTest.java +++ b/wifi/tests/src/android/net/wifi/WifiConfigurationTest.java @@ -22,6 +22,7 @@ import static org.junit.Assert.assertTrue; import static org.junit.Assert.assertFalse; import android.os.Parcel; +import android.net.MacAddress; import android.net.wifi.WifiConfiguration.NetworkSelectionStatus; import org.junit.Before; @@ -49,6 +50,7 @@ public class WifiConfigurationTest { String cookie = "C O.o |<IE"; WifiConfiguration config = new WifiConfiguration(); config.setPasspointManagementObjectTree(cookie); + MacAddress macBeforeParcel = config.getOrCreateRandomizedMacAddress(); Parcel parcelW = Parcel.obtain(); config.writeToParcel(parcelW, 0); byte[] bytes = parcelW.marshall(); @@ -59,8 +61,9 @@ public class WifiConfigurationTest { parcelR.setDataPosition(0); WifiConfiguration reconfig = WifiConfiguration.CREATOR.createFromParcel(parcelR); - // lacking a useful config.equals, check one field near the end. + // lacking a useful config.equals, check two fields near the end. assertEquals(cookie, reconfig.getMoTree()); + assertEquals(macBeforeParcel, reconfig.getOrCreateRandomizedMacAddress()); Parcel parcelWW = Parcel.obtain(); reconfig.writeToParcel(parcelWW, 0); @@ -169,4 +172,52 @@ public class WifiConfigurationTest { assertFalse(config.isOpenNetwork()); } + + @Test + public void testGetOrCreateRandomizedMacAddress_SavesAndReturnsSameAddress() { + WifiConfiguration config = new WifiConfiguration(); + assertEquals(MacAddress.ALL_ZEROS_ADDRESS, config.getRandomizedMacAddress()); + + MacAddress firstMacAddress = config.getOrCreateRandomizedMacAddress(); + MacAddress secondMacAddress = config.getOrCreateRandomizedMacAddress(); + + assertEquals(firstMacAddress, secondMacAddress); + } + + @Test + public void testSetRandomizedMacAddress_ChangesSavedAddress() { + WifiConfiguration config = new WifiConfiguration(); + assertEquals(MacAddress.ALL_ZEROS_ADDRESS, config.getRandomizedMacAddress()); + + MacAddress macToChangeInto = MacAddress.createRandomUnicastAddress(); + config.setRandomizedMacAddress(macToChangeInto); + MacAddress macAfterChange = config.getOrCreateRandomizedMacAddress(); + + assertEquals(macToChangeInto, macAfterChange); + } + + @Test + public void testGetOrCreateRandomizedMacAddress_ReRandomizesInvalidAddress() { + WifiConfiguration config = new WifiConfiguration(); + + MacAddress macAddressZeroes = MacAddress.ALL_ZEROS_ADDRESS; + MacAddress macAddressMulticast = MacAddress.fromString("03:ff:ff:ff:ff:ff"); + MacAddress macAddressGlobal = MacAddress.fromString("fc:ff:ff:ff:ff:ff"); + + config.setRandomizedMacAddress(null); + MacAddress macAfterChange = config.getOrCreateRandomizedMacAddress(); + assertFalse(macAfterChange.equals(null)); + + config.setRandomizedMacAddress(macAddressZeroes); + macAfterChange = config.getOrCreateRandomizedMacAddress(); + assertFalse(macAfterChange.equals(macAddressZeroes)); + + config.setRandomizedMacAddress(macAddressMulticast); + macAfterChange = config.getOrCreateRandomizedMacAddress(); + assertFalse(macAfterChange.equals(macAddressMulticast)); + + config.setRandomizedMacAddress(macAddressGlobal); + macAfterChange = config.getOrCreateRandomizedMacAddress(); + assertFalse(macAfterChange.equals(macAddressGlobal)); + } } diff --git a/wifi/tests/src/android/net/wifi/WifiEnterpriseConfigTest.java b/wifi/tests/src/android/net/wifi/WifiEnterpriseConfigTest.java index 1a7dd132389e..e569efef5d91 100644 --- a/wifi/tests/src/android/net/wifi/WifiEnterpriseConfigTest.java +++ b/wifi/tests/src/android/net/wifi/WifiEnterpriseConfigTest.java @@ -28,7 +28,7 @@ import android.net.wifi.WifiEnterpriseConfig.Eap; import android.net.wifi.WifiEnterpriseConfig.Phase2; import android.os.Parcel; import android.security.Credentials; -import android.test.suitebuilder.annotation.SmallTest; +import android.support.test.filters.SmallTest; import org.junit.Before; import org.junit.Test; diff --git a/wifi/tests/src/android/net/wifi/WifiManagerTest.java b/wifi/tests/src/android/net/wifi/WifiManagerTest.java index 8ac659f83b5e..f3a78bd01cbe 100644 --- a/wifi/tests/src/android/net/wifi/WifiManagerTest.java +++ b/wifi/tests/src/android/net/wifi/WifiManagerTest.java @@ -24,11 +24,20 @@ import static android.net.wifi.WifiManager.LocalOnlyHotspotCallback.ERROR_INCOMP import static android.net.wifi.WifiManager.LocalOnlyHotspotCallback.ERROR_NO_CHANNEL; import static android.net.wifi.WifiManager.LocalOnlyHotspotCallback.ERROR_TETHERING_DISALLOWED; import static android.net.wifi.WifiManager.LocalOnlyHotspotCallback.REQUEST_REGISTERED; +import static android.net.wifi.WifiManager.SAP_START_FAILURE_GENERAL; +import static android.net.wifi.WifiManager.SAP_START_FAILURE_NO_CHANNEL; +import static android.net.wifi.WifiManager.WIFI_AP_STATE_DISABLED; +import static android.net.wifi.WifiManager.WIFI_AP_STATE_DISABLING; +import static android.net.wifi.WifiManager.WIFI_AP_STATE_ENABLED; +import static android.net.wifi.WifiManager.WIFI_AP_STATE_ENABLING; +import static android.net.wifi.WifiManager.WIFI_AP_STATE_FAILED; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNull; import static org.junit.Assert.assertTrue; +import static org.junit.Assert.fail; import static org.mockito.Mockito.*; import android.content.Context; @@ -37,12 +46,13 @@ import android.net.wifi.WifiManager.LocalOnlyHotspotCallback; import android.net.wifi.WifiManager.LocalOnlyHotspotObserver; import android.net.wifi.WifiManager.LocalOnlyHotspotReservation; import android.net.wifi.WifiManager.LocalOnlyHotspotSubscription; +import android.net.wifi.WifiManager.SoftApCallback; import android.os.Handler; import android.os.IBinder; import android.os.Message; import android.os.Messenger; import android.os.test.TestLooper; -import android.test.suitebuilder.annotation.SmallTest; +import android.support.test.filters.SmallTest; import org.junit.Before; import org.junit.Test; @@ -59,12 +69,14 @@ public class WifiManagerTest { private static final int ERROR_NOT_SET = -1; private static final int ERROR_TEST_REASON = 5; private static final String TEST_PACKAGE_NAME = "TestPackage"; + private static final String TEST_COUNTRY_CODE = "US"; @Mock Context mContext; @Mock IWifiManager mWifiService; @Mock ApplicationInfo mApplicationInfo; @Mock WifiConfiguration mApConfig; @Mock IBinder mAppBinder; + @Mock SoftApCallback mSoftApCallback; private Handler mHandler; private TestLooper mLooper; @@ -632,6 +644,149 @@ public class WifiManagerTest { } /** + * Verify an IllegalArgumentException is thrown if callback is not provided. + */ + @Test + public void registerSoftApCallbackThrowsIllegalArgumentExceptionOnNullArgumentForCallback() { + try { + mWifiManager.registerSoftApCallback(null, mHandler); + fail("expected IllegalArgumentException"); + } catch (IllegalArgumentException expected) { + } + } + + /** + * Verify an IllegalArgumentException is thrown if callback is not provided. + */ + @Test + public void unregisterSoftApCallbackThrowsIllegalArgumentExceptionOnNullArgumentForCallback() { + try { + mWifiManager.unregisterSoftApCallback(null); + fail("expected IllegalArgumentException"); + } catch (IllegalArgumentException expected) { + } + } + + /** + * Verify main looper is used when handler is not provided. + */ + @Test + public void registerSoftApCallbackUsesMainLooperOnNullArgumentForHandler() { + when(mContext.getMainLooper()).thenReturn(mLooper.getLooper()); + mWifiManager.registerSoftApCallback(mSoftApCallback, null); + verify(mContext).getMainLooper(); + } + + /** + * Verify the call to registerSoftApCallback goes to WifiServiceImpl. + */ + @Test + public void registerSoftApCallbackCallGoesToWifiServiceImpl() throws Exception { + mWifiManager.registerSoftApCallback(mSoftApCallback, mHandler); + verify(mWifiService).registerSoftApCallback(any(IBinder.class), + any(ISoftApCallback.Stub.class), anyInt()); + } + + /** + * Verify the call to unregisterSoftApCallback goes to WifiServiceImpl. + */ + @Test + public void unregisterSoftApCallbackCallGoesToWifiServiceImpl() throws Exception { + ArgumentCaptor<Integer> callbackIdentifier = ArgumentCaptor.forClass(Integer.class); + mWifiManager.registerSoftApCallback(mSoftApCallback, mHandler); + verify(mWifiService).registerSoftApCallback(any(IBinder.class), + any(ISoftApCallback.Stub.class), callbackIdentifier.capture()); + + mWifiManager.unregisterSoftApCallback(mSoftApCallback); + verify(mWifiService).unregisterSoftApCallback(eq((int) callbackIdentifier.getValue())); + } + + /* + * Verify client provided callback is being called through callback proxy + */ + @Test + public void softApCallbackProxyCallsOnStateChanged() throws Exception { + ArgumentCaptor<ISoftApCallback.Stub> callbackCaptor = + ArgumentCaptor.forClass(ISoftApCallback.Stub.class); + mWifiManager.registerSoftApCallback(mSoftApCallback, mHandler); + verify(mWifiService).registerSoftApCallback(any(IBinder.class), callbackCaptor.capture(), + anyInt()); + + callbackCaptor.getValue().onStateChanged(WIFI_AP_STATE_ENABLED, 0); + mLooper.dispatchAll(); + verify(mSoftApCallback).onStateChanged(WIFI_AP_STATE_ENABLED, 0); + } + + /* + * Verify client provided callback is being called through callback proxy + */ + @Test + public void softApCallbackProxyCallsOnNumClientsChanged() throws Exception { + ArgumentCaptor<ISoftApCallback.Stub> callbackCaptor = + ArgumentCaptor.forClass(ISoftApCallback.Stub.class); + mWifiManager.registerSoftApCallback(mSoftApCallback, mHandler); + verify(mWifiService).registerSoftApCallback(any(IBinder.class), callbackCaptor.capture(), + anyInt()); + + final int testNumClients = 3; + callbackCaptor.getValue().onNumClientsChanged(testNumClients); + mLooper.dispatchAll(); + verify(mSoftApCallback).onNumClientsChanged(testNumClients); + } + + /* + * Verify client provided callback is being called through callback proxy on multiple events + */ + @Test + public void softApCallbackProxyCallsOnMultipleUpdates() throws Exception { + ArgumentCaptor<ISoftApCallback.Stub> callbackCaptor = + ArgumentCaptor.forClass(ISoftApCallback.Stub.class); + mWifiManager.registerSoftApCallback(mSoftApCallback, mHandler); + verify(mWifiService).registerSoftApCallback(any(IBinder.class), callbackCaptor.capture(), + anyInt()); + + final int testNumClients = 5; + callbackCaptor.getValue().onStateChanged(WIFI_AP_STATE_ENABLING, 0); + callbackCaptor.getValue().onNumClientsChanged(testNumClients); + callbackCaptor.getValue().onStateChanged(WIFI_AP_STATE_FAILED, SAP_START_FAILURE_GENERAL); + + mLooper.dispatchAll(); + verify(mSoftApCallback).onStateChanged(WIFI_AP_STATE_ENABLING, 0); + verify(mSoftApCallback).onNumClientsChanged(testNumClients); + verify(mSoftApCallback).onStateChanged(WIFI_AP_STATE_FAILED, SAP_START_FAILURE_GENERAL); + } + + /* + * Verify client provided callback is being called on the correct thread + */ + @Test + public void softApCallbackIsCalledOnCorrectThread() throws Exception { + ArgumentCaptor<ISoftApCallback.Stub> callbackCaptor = + ArgumentCaptor.forClass(ISoftApCallback.Stub.class); + TestLooper altLooper = new TestLooper(); + Handler altHandler = new Handler(altLooper.getLooper()); + mWifiManager.registerSoftApCallback(mSoftApCallback, altHandler); + verify(mWifiService).registerSoftApCallback(any(IBinder.class), callbackCaptor.capture(), + anyInt()); + + callbackCaptor.getValue().onStateChanged(WIFI_AP_STATE_ENABLED, 0); + altLooper.dispatchAll(); + verify(mSoftApCallback).onStateChanged(WIFI_AP_STATE_ENABLED, 0); + } + + /** + * Verify that the handler provided by the caller is used for registering soft AP callback. + */ + @Test + public void testCorrectLooperIsUsedForSoftApCallbackHandler() throws Exception { + mWifiManager.registerSoftApCallback(mSoftApCallback, mHandler); + mLooper.dispatchAll(); + verify(mWifiService).registerSoftApCallback(any(IBinder.class), + any(ISoftApCallback.Stub.class), anyInt()); + verify(mContext, never()).getMainLooper(); + } + + /** * Verify that the handler provided by the caller is used for the observer. */ @Test @@ -780,12 +935,103 @@ public class WifiManagerTest { } /** - * Verify that calls to setWifiApEnabled return false. + * Verify that calls WifiServiceImpl to set country code when no exception happens. + */ + @Test + public void testSetWifiCountryCode() throws Exception { + mWifiManager.setCountryCode(TEST_COUNTRY_CODE); + verify(mWifiService).setCountryCode(TEST_COUNTRY_CODE); + } + + /** + * Verify that WifiManager.setCountryCode() rethrows exceptions if caller does not + * have necessary permissions. + */ + @Test(expected = SecurityException.class) + public void testSetWifiCountryCodeFailedOnSecurityException() throws Exception { + doThrow(new SecurityException()).when(mWifiService).setCountryCode(anyString()); + mWifiManager.setCountryCode(TEST_COUNTRY_CODE); + } + + /** + * Test that calls to get the current WPS config token return null and do not have any + * interactions with WifiServiceImpl. + */ + @Test + public void testGetCurrentNetworkWpsNfcConfigurationTokenReturnsNull() { + assertNull(mWifiManager.getCurrentNetworkWpsNfcConfigurationToken()); + verifyNoMoreInteractions(mWifiService); + } + + + class WpsCallbackTester extends WifiManager.WpsCallback { + public boolean mStarted = false; + public boolean mSucceeded = false; + public boolean mFailed = false; + public int mFailureCode = -1; + + @Override + public void onStarted(String pin) { + mStarted = true; + } + + @Override + public void onSucceeded() { + mSucceeded = true; + } + + @Override + public void onFailed(int reason) { + mFailed = true; + mFailureCode = reason; + } + + } + + /** + * Verify that a call to start WPS immediately returns a failure. + */ + @Test + public void testStartWpsImmediatelyFailsWithCallback() { + WpsCallbackTester wpsCallback = new WpsCallbackTester(); + mWifiManager.startWps(null, wpsCallback); + assertTrue(wpsCallback.mFailed); + assertEquals(WifiManager.ERROR, wpsCallback.mFailureCode); + assertFalse(wpsCallback.mStarted); + assertFalse(wpsCallback.mSucceeded); + verifyNoMoreInteractions(mWifiService); + } + + /** + * Verify that a call to start WPS does not go to WifiServiceImpl if we do not have a callback. + */ + @Test + public void testStartWpsDoesNotCallWifiServiceImpl() { + mWifiManager.startWps(null, null); + verifyNoMoreInteractions(mWifiService); + } + + /** +i * Verify that a call to cancel WPS immediately returns a failure. */ @Test - public void testSetWifiApEnabledReturnsFalse() throws Exception { - assertFalse(mWifiManager.setWifiApEnabled(null, true)); - assertFalse(mWifiManager.setWifiApEnabled(null, false)); - verify(mWifiService, never()).setWifiApEnabled(any(), anyBoolean()); + public void testCancelWpsImmediatelyFailsWithCallback() { + WpsCallbackTester wpsCallback = new WpsCallbackTester(); + mWifiManager.cancelWps(wpsCallback); + assertTrue(wpsCallback.mFailed); + assertEquals(WifiManager.ERROR, wpsCallback.mFailureCode); + assertFalse(wpsCallback.mStarted); + assertFalse(wpsCallback.mSucceeded); + verifyNoMoreInteractions(mWifiService); } + + /** + * Verify that a call to cancel WPS does not go to WifiServiceImpl if we do not have a callback. + */ + @Test + public void testCancelWpsDoesNotCallWifiServiceImpl() { + mWifiManager.cancelWps(null); + verifyNoMoreInteractions(mWifiService); + } + } diff --git a/wifi/tests/src/android/net/wifi/WifiScannerTest.java b/wifi/tests/src/android/net/wifi/WifiScannerTest.java index e542789e01e3..96d5a5167480 100644 --- a/wifi/tests/src/android/net/wifi/WifiScannerTest.java +++ b/wifi/tests/src/android/net/wifi/WifiScannerTest.java @@ -16,19 +16,23 @@ package android.net.wifi; +import static org.junit.Assert.assertEquals; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.validateMockitoUsage; import static org.mockito.Mockito.when; import android.content.Context; import android.os.Handler; +import android.os.Parcel; import android.os.test.TestLooper; -import android.test.suitebuilder.annotation.SmallTest; +import android.support.test.filters.SmallTest; +import android.net.wifi.WifiScanner.ScanSettings; import com.android.internal.util.test.BidirectionalAsyncChannelServer; import org.junit.After; import org.junit.Before; +import org.junit.Test; import org.mockito.Mock; import org.mockito.MockitoAnnotations; @@ -70,4 +74,50 @@ public class WifiScannerTest { validateMockitoUsage(); } + /** + * Verify parcel read/write for ScanSettings. + */ + @Test + public void verifyScanSettingsParcelWithBand() throws Exception { + ScanSettings writeSettings = new ScanSettings(); + writeSettings.type = WifiScanner.TYPE_LOW_POWER; + writeSettings.band = WifiScanner.WIFI_BAND_BOTH_WITH_DFS; + + ScanSettings readSettings = parcelWriteRead(writeSettings); + assertEquals(readSettings.type, writeSettings.type); + assertEquals(readSettings.band, writeSettings.band); + assertEquals(0, readSettings.channels.length); + } + + /** + * Verify parcel read/write for ScanSettings. + */ + @Test + public void verifyScanSettingsParcelWithChannels() throws Exception { + ScanSettings writeSettings = new ScanSettings(); + writeSettings.type = WifiScanner.TYPE_HIGH_ACCURACY; + writeSettings.band = WifiScanner.WIFI_BAND_UNSPECIFIED; + writeSettings.channels = new WifiScanner.ChannelSpec[] { + new WifiScanner.ChannelSpec(5), + new WifiScanner.ChannelSpec(7) + }; + + ScanSettings readSettings = parcelWriteRead(writeSettings); + assertEquals(writeSettings.type, readSettings.type); + assertEquals(writeSettings.band, readSettings.band); + assertEquals(2, readSettings.channels.length); + assertEquals(5, readSettings.channels[0].frequency); + assertEquals(7, readSettings.channels[1].frequency); + } + + /** + * Write the provided {@link ScanSettings} to a parcel and deserialize it. + */ + private static ScanSettings parcelWriteRead(ScanSettings writeSettings) throws Exception { + Parcel parcel = Parcel.obtain(); + writeSettings.writeToParcel(parcel, 0); + parcel.setDataPosition(0); // Rewind data position back to the beginning for read. + return ScanSettings.CREATOR.createFromParcel(parcel); + } + } diff --git a/wifi/tests/src/android/net/wifi/aware/TlvBufferUtilsTest.java b/wifi/tests/src/android/net/wifi/aware/TlvBufferUtilsTest.java index 15641abd11f9..6ecd93114dc2 100644 --- a/wifi/tests/src/android/net/wifi/aware/TlvBufferUtilsTest.java +++ b/wifi/tests/src/android/net/wifi/aware/TlvBufferUtilsTest.java @@ -18,7 +18,7 @@ package android.net.wifi.aware; import static org.hamcrest.core.IsEqual.equalTo; -import android.test.suitebuilder.annotation.SmallTest; +import android.support.test.filters.SmallTest; import org.junit.Rule; import org.junit.Test; diff --git a/wifi/tests/src/android/net/wifi/aware/WifiAwareAgentNetworkSpecifierTest.java b/wifi/tests/src/android/net/wifi/aware/WifiAwareAgentNetworkSpecifierTest.java index 2dd0537a7aff..0515e0637e03 100644 --- a/wifi/tests/src/android/net/wifi/aware/WifiAwareAgentNetworkSpecifierTest.java +++ b/wifi/tests/src/android/net/wifi/aware/WifiAwareAgentNetworkSpecifierTest.java @@ -20,7 +20,7 @@ import static org.hamcrest.core.IsEqual.equalTo; import static org.junit.Assert.assertEquals; import android.os.Parcel; -import android.test.suitebuilder.annotation.SmallTest; +import android.support.test.filters.SmallTest; import org.junit.Rule; import org.junit.Test; diff --git a/wifi/tests/src/android/net/wifi/aware/WifiAwareManagerTest.java b/wifi/tests/src/android/net/wifi/aware/WifiAwareManagerTest.java index d9433c5a9d00..84e3ed9d2c44 100644 --- a/wifi/tests/src/android/net/wifi/aware/WifiAwareManagerTest.java +++ b/wifi/tests/src/android/net/wifi/aware/WifiAwareManagerTest.java @@ -19,22 +19,19 @@ package android.net.wifi.aware; import static org.hamcrest.core.IsEqual.equalTo; import static org.junit.Assert.assertEquals; import static org.mockito.ArgumentMatchers.any; -import static org.mockito.ArgumentMatchers.anyInt; import static org.mockito.ArgumentMatchers.eq; import static org.mockito.ArgumentMatchers.isNull; import static org.mockito.Mockito.inOrder; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.verifyNoMoreInteractions; -import static org.mockito.Mockito.when; import android.content.Context; import android.net.wifi.RttManager; import android.os.Handler; import android.os.IBinder; import android.os.Parcel; -import android.os.RemoteException; import android.os.test.TestLooper; -import android.test.suitebuilder.annotation.SmallTest; +import android.support.test.filters.SmallTest; import libcore.util.HexEncoding; @@ -148,7 +145,7 @@ public class WifiAwareManagerTest { // (2) publish - should succeed PublishConfig publishConfig = new PublishConfig.Builder().build(); session.publish(publishConfig, mockSessionCallback, mMockLooperHandler); - inOrder.verify(mockAwareService).publish(eq(clientId), eq(publishConfig), any()); + inOrder.verify(mockAwareService).publish(any(), eq(clientId), eq(publishConfig), any()); // (3) disconnect session.close(); @@ -200,7 +197,7 @@ public class WifiAwareManagerTest { // (4) subscribe: should succeed SubscribeConfig subscribeConfig = new SubscribeConfig.Builder().build(); session.subscribe(subscribeConfig, mockSessionCallback, mMockLooperHandler); - inOrder.verify(mockAwareService).subscribe(eq(clientId), eq(subscribeConfig), any()); + inOrder.verify(mockAwareService).subscribe(any(), eq(clientId), eq(subscribeConfig), any()); verifyNoMoreInteractions(mockCallback, mockSessionCallback, mockAwareService); } @@ -283,7 +280,7 @@ public class WifiAwareManagerTest { // (1) publish session.publish(publishConfig, mockSessionCallback, mMockLooperHandler); - inOrder.verify(mockAwareService).publish(eq(clientId), eq(publishConfig), + inOrder.verify(mockAwareService).publish(any(), eq(clientId), eq(publishConfig), sessionProxyCallback.capture()); // (2) publish session created @@ -375,7 +372,7 @@ public class WifiAwareManagerTest { // (2) publish: successfully - then terminated session.publish(publishConfig, mockSessionCallback, mMockLooperHandler); - inOrder.verify(mockAwareService).publish(eq(clientId), eq(publishConfig), + inOrder.verify(mockAwareService).publish(any(), eq(clientId), eq(publishConfig), sessionProxyCallback.capture()); sessionProxyCallback.getValue().onSessionStarted(sessionId); sessionProxyCallback.getValue().onSessionTerminated(0); @@ -407,6 +404,7 @@ public class WifiAwareManagerTest { final byte[] matchFilter = { 1, 12, 3, 31, 32 }; // bad data! final int messageId = 2123; final int reason = AWARE_STATUS_ERROR; + final int distanceMm = 100; InOrder inOrder = inOrder(mockCallback, mockSessionCallback, mockAwareService, mockSubscribeSession); @@ -431,7 +429,7 @@ public class WifiAwareManagerTest { // (1) subscribe session.subscribe(subscribeConfig, mockSessionCallback, mMockLooperHandler); - inOrder.verify(mockAwareService).subscribe(eq(clientId), eq(subscribeConfig), + inOrder.verify(mockAwareService).subscribe(any(), eq(clientId), eq(subscribeConfig), sessionProxyCallback.capture()); // (2) subscribe session created @@ -442,6 +440,8 @@ public class WifiAwareManagerTest { // (3) ... subscribeSession.getValue().sendMessage(peerHandle, messageId, string1.getBytes()); sessionProxyCallback.getValue().onMatch(peerHandle.peerId, string1.getBytes(), matchFilter); + sessionProxyCallback.getValue().onMatchWithDistance(peerHandle.peerId, string1.getBytes(), + matchFilter, distanceMm); sessionProxyCallback.getValue().onMessageReceived(peerHandle.peerId, string1.getBytes()); sessionProxyCallback.getValue().onMessageSendFail(messageId, reason); sessionProxyCallback.getValue().onMessageSendSuccess(messageId); @@ -450,7 +450,9 @@ public class WifiAwareManagerTest { inOrder.verify(mockAwareService).sendMessage(eq(clientId), eq(sessionId), eq(peerHandle.peerId), eq(string1.getBytes()), eq(messageId), eq(0)); inOrder.verify(mockSessionCallback).onServiceDiscovered(peerIdCaptor.capture(), - eq(string1.getBytes()), (List<byte[]>) isNull()); + eq(string1.getBytes()), isNull()); + inOrder.verify(mockSessionCallback).onServiceDiscoveredWithinRange(peerIdCaptor.capture(), + eq(string1.getBytes()), isNull(), eq(distanceMm)); assertEquals((peerIdCaptor.getValue()).peerId, peerHandle.peerId); inOrder.verify(mockSessionCallback).onMessageReceived(peerIdCaptor.capture(), eq(string1.getBytes())); @@ -512,7 +514,7 @@ public class WifiAwareManagerTest { // (2) subscribe: successfully - then terminated session.subscribe(subscribeConfig, mockSessionCallback, mMockLooperHandler); - inOrder.verify(mockAwareService).subscribe(eq(clientId), eq(subscribeConfig), + inOrder.verify(mockAwareService).subscribe(any(), eq(clientId), eq(subscribeConfig), sessionProxyCallback.capture()); sessionProxyCallback.getValue().onSessionStarted(sessionId); sessionProxyCallback.getValue().onSessionTerminated(0); @@ -685,11 +687,18 @@ public class WifiAwareManagerTest { SubscribeConfig subscribeConfig = new SubscribeConfig.Builder().build(); collector.checkThat("mServiceName", subscribeConfig.mServiceName, equalTo(null)); + collector.checkThat("mServiceSpecificInfo", subscribeConfig.mServiceSpecificInfo, + equalTo(null)); + collector.checkThat("mMatchFilter", subscribeConfig.mMatchFilter, equalTo(null)); collector.checkThat("mSubscribeType", subscribeConfig.mSubscribeType, equalTo(SubscribeConfig.SUBSCRIBE_TYPE_PASSIVE)); collector.checkThat("mTtlSec", subscribeConfig.mTtlSec, equalTo(0)); collector.checkThat("mEnableTerminateNotification", subscribeConfig.mEnableTerminateNotification, equalTo(true)); + collector.checkThat("mMinDistanceCmSet", subscribeConfig.mMinDistanceMmSet, equalTo(false)); + collector.checkThat("mMinDistanceMm", subscribeConfig.mMinDistanceMm, equalTo(0)); + collector.checkThat("mMaxDistanceMmSet", subscribeConfig.mMaxDistanceMmSet, equalTo(false)); + collector.checkThat("mMaxDistanceMm", subscribeConfig.mMaxDistanceMm, equalTo(0)); } @Test @@ -698,16 +707,19 @@ public class WifiAwareManagerTest { final String serviceSpecificInfo = "long arbitrary string with some info"; final byte[] matchFilter = { 1, 16, 1, 22 }; final int subscribeType = SubscribeConfig.SUBSCRIBE_TYPE_PASSIVE; - final int subscribeCount = 10; final int subscribeTtl = 15; final boolean enableTerminateNotification = false; + final int minDistance = 10; + final int maxDistance = 50; SubscribeConfig subscribeConfig = new SubscribeConfig.Builder().setServiceName(serviceName) .setServiceSpecificInfo(serviceSpecificInfo.getBytes()).setMatchFilter( - new TlvBufferUtils.TlvIterable(0, 1, matchFilter).toList()) + new TlvBufferUtils.TlvIterable(0, 1, matchFilter).toList()) .setSubscribeType(subscribeType) .setTtlSec(subscribeTtl) - .setTerminateNotificationEnabled(enableTerminateNotification).build(); + .setTerminateNotificationEnabled(enableTerminateNotification) + .setMinDistanceMm(minDistance) + .setMaxDistanceMm(maxDistance).build(); collector.checkThat("mServiceName", serviceName.getBytes(), equalTo(subscribeConfig.mServiceName)); @@ -719,6 +731,10 @@ public class WifiAwareManagerTest { collector.checkThat("mTtlSec", subscribeTtl, equalTo(subscribeConfig.mTtlSec)); collector.checkThat("mEnableTerminateNotification", enableTerminateNotification, equalTo(subscribeConfig.mEnableTerminateNotification)); + collector.checkThat("mMinDistanceMmSet", true, equalTo(subscribeConfig.mMinDistanceMmSet)); + collector.checkThat("mMinDistanceMm", minDistance, equalTo(subscribeConfig.mMinDistanceMm)); + collector.checkThat("mMaxDistanceMmSet", true, equalTo(subscribeConfig.mMaxDistanceMmSet)); + collector.checkThat("mMaxDistanceMm", maxDistance, equalTo(subscribeConfig.mMaxDistanceMm)); } @Test @@ -729,13 +745,17 @@ public class WifiAwareManagerTest { final int subscribeType = SubscribeConfig.SUBSCRIBE_TYPE_PASSIVE; final int subscribeTtl = 15; final boolean enableTerminateNotification = true; + final int minDistance = 10; + final int maxDistance = 50; SubscribeConfig subscribeConfig = new SubscribeConfig.Builder().setServiceName(serviceName) .setServiceSpecificInfo(serviceSpecificInfo.getBytes()).setMatchFilter( new TlvBufferUtils.TlvIterable(0, 1, matchFilter).toList()) .setSubscribeType(subscribeType) .setTtlSec(subscribeTtl) - .setTerminateNotificationEnabled(enableTerminateNotification).build(); + .setTerminateNotificationEnabled(enableTerminateNotification) + .setMinDistanceMm(minDistance) + .setMaxDistanceMm(maxDistance).build(); Parcel parcelW = Parcel.obtain(); subscribeConfig.writeToParcel(parcelW, 0); @@ -769,11 +789,15 @@ public class WifiAwareManagerTest { PublishConfig publishConfig = new PublishConfig.Builder().build(); collector.checkThat("mServiceName", publishConfig.mServiceName, equalTo(null)); + collector.checkThat("mServiceSpecificInfo", publishConfig.mServiceSpecificInfo, + equalTo(null)); + collector.checkThat("mMatchFilter", publishConfig.mMatchFilter, equalTo(null)); collector.checkThat("mPublishType", publishConfig.mPublishType, equalTo(PublishConfig.PUBLISH_TYPE_UNSOLICITED)); collector.checkThat("mTtlSec", publishConfig.mTtlSec, equalTo(0)); collector.checkThat("mEnableTerminateNotification", publishConfig.mEnableTerminateNotification, equalTo(true)); + collector.checkThat("mEnableRanging", publishConfig.mEnableRanging, equalTo(false)); } @Test @@ -782,16 +806,17 @@ public class WifiAwareManagerTest { final String serviceSpecificInfo = "long arbitrary string with some info"; final byte[] matchFilter = { 1, 16, 1, 22 }; final int publishType = PublishConfig.PUBLISH_TYPE_SOLICITED; - final int publishCount = 10; final int publishTtl = 15; final boolean enableTerminateNotification = false; + final boolean enableRanging = true; PublishConfig publishConfig = new PublishConfig.Builder().setServiceName(serviceName) .setServiceSpecificInfo(serviceSpecificInfo.getBytes()).setMatchFilter( new TlvBufferUtils.TlvIterable(0, 1, matchFilter).toList()) .setPublishType(publishType) .setTtlSec(publishTtl) - .setTerminateNotificationEnabled(enableTerminateNotification).build(); + .setTerminateNotificationEnabled(enableTerminateNotification) + .setRangingEnabled(enableRanging).build(); collector.checkThat("mServiceName", serviceName.getBytes(), equalTo(publishConfig.mServiceName)); @@ -802,6 +827,7 @@ public class WifiAwareManagerTest { collector.checkThat("mTtlSec", publishTtl, equalTo(publishConfig.mTtlSec)); collector.checkThat("mEnableTerminateNotification", enableTerminateNotification, equalTo(publishConfig.mEnableTerminateNotification)); + collector.checkThat("mEnableRanging", enableRanging, equalTo(publishConfig.mEnableRanging)); } @Test @@ -810,16 +836,17 @@ public class WifiAwareManagerTest { final String serviceSpecificInfo = "long arbitrary string with some info"; final byte[] matchFilter = { 1, 16, 1, 22 }; final int publishType = PublishConfig.PUBLISH_TYPE_SOLICITED; - final int publishCount = 10; final int publishTtl = 15; final boolean enableTerminateNotification = false; + final boolean enableRanging = true; PublishConfig publishConfig = new PublishConfig.Builder().setServiceName(serviceName) .setServiceSpecificInfo(serviceSpecificInfo.getBytes()).setMatchFilter( new TlvBufferUtils.TlvIterable(0, 1, matchFilter).toList()) .setPublishType(publishType) .setTtlSec(publishTtl) - .setTerminateNotificationEnabled(enableTerminateNotification).build(); + .setTerminateNotificationEnabled(enableTerminateNotification) + .setRangingEnabled(enableRanging).build(); Parcel parcelW = Parcel.obtain(); publishConfig.writeToParcel(parcelW, 0); @@ -845,88 +872,6 @@ public class WifiAwareManagerTest { } /* - * Ranging tests - */ - - /** - * Validate ranging + success flow: (1) connect, (2) create a (publish) session, (3) start - * ranging, (4) ranging success callback, (5) ranging aborted callback ignored (since - * listener removed). - */ - @Test - public void testRangingCallbacks() throws Exception { - final int clientId = 4565; - final int sessionId = 123; - final int rangingId = 3482; - final ConfigRequest configRequest = new ConfigRequest.Builder().build(); - final PublishConfig publishConfig = new PublishConfig.Builder().build(); - final RttManager.RttParams rttParams = new RttManager.RttParams(); - rttParams.deviceType = RttManager.RTT_PEER_NAN; - rttParams.bssid = Integer.toString(1234); - final RttManager.RttResult rttResults = new RttManager.RttResult(); - rttResults.distance = 10; - - when(mockAwareService.startRanging(anyInt(), anyInt(), any())).thenReturn(rangingId); - - InOrder inOrder = inOrder(mockCallback, mockSessionCallback, mockAwareService, - mockPublishSession, mockRttListener); - ArgumentCaptor<WifiAwareSession> sessionCaptor = ArgumentCaptor.forClass( - WifiAwareSession.class); - ArgumentCaptor<IWifiAwareEventCallback> clientProxyCallback = ArgumentCaptor - .forClass(IWifiAwareEventCallback.class); - ArgumentCaptor<IWifiAwareDiscoverySessionCallback> sessionProxyCallback = ArgumentCaptor - .forClass(IWifiAwareDiscoverySessionCallback.class); - ArgumentCaptor<PublishDiscoverySession> publishSession = ArgumentCaptor - .forClass(PublishDiscoverySession.class); - ArgumentCaptor<RttManager.ParcelableRttParams> rttParamCaptor = ArgumentCaptor - .forClass(RttManager.ParcelableRttParams.class); - ArgumentCaptor<RttManager.RttResult[]> rttResultsCaptor = ArgumentCaptor - .forClass(RttManager.RttResult[].class); - - // (1) connect successfully - mDut.attach(mMockLooperHandler, configRequest, mockCallback, null); - inOrder.verify(mockAwareService).connect(any(), any(), clientProxyCallback.capture(), - eq(configRequest), eq(false)); - clientProxyCallback.getValue().onConnectSuccess(clientId); - mMockLooper.dispatchAll(); - inOrder.verify(mockCallback).onAttached(sessionCaptor.capture()); - WifiAwareSession session = sessionCaptor.getValue(); - - // (2) publish successfully - session.publish(publishConfig, mockSessionCallback, mMockLooperHandler); - inOrder.verify(mockAwareService).publish(eq(clientId), eq(publishConfig), - sessionProxyCallback.capture()); - sessionProxyCallback.getValue().onSessionStarted(sessionId); - mMockLooper.dispatchAll(); - inOrder.verify(mockSessionCallback).onPublishStarted(publishSession.capture()); - - // (3) start ranging - publishSession.getValue().startRanging(new RttManager.RttParams[]{rttParams}, - mockRttListener); - inOrder.verify(mockAwareService).startRanging(eq(clientId), eq(sessionId), - rttParamCaptor.capture()); - collector.checkThat("RttParams.deviceType", rttParams.deviceType, - equalTo(rttParamCaptor.getValue().mParams[0].deviceType)); - collector.checkThat("RttParams.bssid", rttParams.bssid, - equalTo(rttParamCaptor.getValue().mParams[0].bssid)); - - // (4) ranging success callback - clientProxyCallback.getValue().onRangingSuccess(rangingId, - new RttManager.ParcelableRttResults(new RttManager.RttResult[] { rttResults })); - mMockLooper.dispatchAll(); - inOrder.verify(mockRttListener).onSuccess(rttResultsCaptor.capture()); - collector.checkThat("RttResult.distance", rttResults.distance, - equalTo(rttResultsCaptor.getValue()[0].distance)); - - // (5) ranging aborted callback (should be ignored since listener cleared on first callback) - clientProxyCallback.getValue().onRangingAborted(rangingId); - mMockLooper.dispatchAll(); - - verifyNoMoreInteractions(mockCallback, mockSessionCallback, mockAwareService, - mockPublishSession, mockRttListener); - } - - /* * Data-path tests */ @@ -967,7 +912,7 @@ public class WifiAwareManagerTest { // (2) publish successfully session.publish(publishConfig, mockSessionCallback, mMockLooperHandler); - inOrder.verify(mockAwareService).publish(eq(clientId), eq(publishConfig), + inOrder.verify(mockAwareService).publish(any(), eq(clientId), eq(publishConfig), sessionProxyCallback.capture()); sessionProxyCallback.getValue().onSessionStarted(sessionId); mMockLooper.dispatchAll(); @@ -1077,7 +1022,7 @@ public class WifiAwareManagerTest { */ @Test(expected = IllegalArgumentException.class) public void testNetworkSpecifierWithClientNullPmk() throws Exception { - executeNetworkSpecifierWithClient(true, null, null); + executeNetworkSpecifierWithClient(new PeerHandle(123412), true, null, null); } /** @@ -1085,7 +1030,7 @@ public class WifiAwareManagerTest { */ @Test(expected = IllegalArgumentException.class) public void testNetworkSpecifierWithClientIncorrectLengthPmk() throws Exception { - executeNetworkSpecifierWithClient(true, "012".getBytes(), null); + executeNetworkSpecifierWithClient(new PeerHandle(123412), true, "012".getBytes(), null); } /** @@ -1093,7 +1038,7 @@ public class WifiAwareManagerTest { */ @Test(expected = IllegalArgumentException.class) public void testNetworkSpecifierWithClientNullPassphrase() throws Exception { - executeNetworkSpecifierWithClient(false, null, null); + executeNetworkSpecifierWithClient(new PeerHandle(123412), false, null, null); } /** @@ -1101,7 +1046,7 @@ public class WifiAwareManagerTest { */ @Test(expected = IllegalArgumentException.class) public void testNetworkSpecifierWithClientShortPassphrase() throws Exception { - executeNetworkSpecifierWithClient(false, null, "012"); + executeNetworkSpecifierWithClient(new PeerHandle(123412), false, null, "012"); } /** @@ -1109,15 +1054,23 @@ public class WifiAwareManagerTest { */ @Test(expected = IllegalArgumentException.class) public void testNetworkSpecifierWithClientLongPassphrase() throws Exception { - executeNetworkSpecifierWithClient(false, null, + executeNetworkSpecifierWithClient(new PeerHandle(123412), false, null, + "0123456789012345678901234567890123456789012345678901234567890123456789"); + } + + /** + * Validate that a null PeerHandle triggers an exception. + */ + @Test(expected = IllegalArgumentException.class) + public void testNetworkSpecifierWithClientNullPeer() throws Exception { + executeNetworkSpecifierWithClient(null, false, null, "0123456789012345678901234567890123456789012345678901234567890123456789"); } - private void executeNetworkSpecifierWithClient(boolean doPmk, byte[] pmk, String passphrase) - throws Exception { + private void executeNetworkSpecifierWithClient(PeerHandle peerHandle, boolean doPmk, byte[] pmk, + String passphrase) throws Exception { final int clientId = 4565; final int sessionId = 123; - final PeerHandle peerHandle = new PeerHandle(123412); final ConfigRequest configRequest = new ConfigRequest.Builder().build(); final PublishConfig publishConfig = new PublishConfig.Builder().build(); @@ -1144,7 +1097,7 @@ public class WifiAwareManagerTest { // (2) publish successfully session.publish(publishConfig, mockSessionCallback, mMockLooperHandler); - inOrder.verify(mockAwareService).publish(eq(clientId), eq(publishConfig), + inOrder.verify(mockAwareService).publish(any(), eq(clientId), eq(publishConfig), sessionProxyCallback.capture()); sessionProxyCallback.getValue().onSessionStarted(sessionId); mMockLooper.dispatchAll(); @@ -1163,7 +1116,8 @@ public class WifiAwareManagerTest { */ @Test(expected = IllegalArgumentException.class) public void testNetworkSpecifierDirectNullPmk() throws Exception { - executeNetworkSpecifierDirect(true, null, null); + executeNetworkSpecifierDirect(HexEncoding.decode("000102030405".toCharArray(), false), true, + null, null); } /** @@ -1171,7 +1125,8 @@ public class WifiAwareManagerTest { */ @Test(expected = IllegalArgumentException.class) public void testNetworkSpecifierDirectIncorrectLengthPmk() throws Exception { - executeNetworkSpecifierDirect(true, "012".getBytes(), null); + executeNetworkSpecifierDirect(HexEncoding.decode("000102030405".toCharArray(), false), true, + "012".getBytes(), null); } /** @@ -1179,7 +1134,8 @@ public class WifiAwareManagerTest { */ @Test(expected = IllegalArgumentException.class) public void testNetworkSpecifierDirectNullPassphrase() throws Exception { - executeNetworkSpecifierDirect(false, null, null); + executeNetworkSpecifierDirect(HexEncoding.decode("000102030405".toCharArray(), false), + false, null, null); } /** @@ -1187,7 +1143,8 @@ public class WifiAwareManagerTest { */ @Test(expected = IllegalArgumentException.class) public void testNetworkSpecifierDirectShortPassphrase() throws Exception { - executeNetworkSpecifierDirect(false, null, "012"); + executeNetworkSpecifierDirect(HexEncoding.decode("000102030405".toCharArray(), false), + false, null, "012"); } /** @@ -1195,14 +1152,22 @@ public class WifiAwareManagerTest { */ @Test(expected = IllegalArgumentException.class) public void testNetworkSpecifierDirectLongPassphrase() throws Exception { - executeNetworkSpecifierDirect(false, null, + executeNetworkSpecifierDirect(HexEncoding.decode("000102030405".toCharArray(), false), + false, null, "0123456789012345678901234567890123456789012345678901234567890123456789"); } - private void executeNetworkSpecifierDirect(boolean doPmk, byte[] pmk, String passphrase) - throws Exception { + /** + * Validate that a null peer MAC triggers an exception. + */ + @Test(expected = IllegalArgumentException.class) + public void testNetworkSpecifierDirectNullPeer() throws Exception { + executeNetworkSpecifierDirect(null, false, null, null); + } + + private void executeNetworkSpecifierDirect(byte[] someMac, boolean doPmk, byte[] pmk, + String passphrase) throws Exception { final int clientId = 134; - final byte[] someMac = HexEncoding.decode("000102030405".toCharArray(), false); final int role = WifiAwareManager.WIFI_AWARE_DATA_PATH_ROLE_INITIATOR; final ConfigRequest configRequest = new ConfigRequest.Builder().build(); diff --git a/wifi/tests/src/android/net/wifi/hotspot2/ConfigParserTest.java b/wifi/tests/src/android/net/wifi/hotspot2/ConfigParserTest.java index 56bb4375acdd..f32fe599cd95 100644 --- a/wifi/tests/src/android/net/wifi/hotspot2/ConfigParserTest.java +++ b/wifi/tests/src/android/net/wifi/hotspot2/ConfigParserTest.java @@ -22,7 +22,7 @@ import static org.junit.Assert.assertTrue; import android.net.wifi.FakeKeys; import android.net.wifi.hotspot2.pps.Credential; import android.net.wifi.hotspot2.pps.HomeSp; -import android.test.suitebuilder.annotation.SmallTest; +import android.support.test.filters.SmallTest; import java.io.BufferedReader; import java.io.IOException; diff --git a/wifi/tests/src/android/net/wifi/hotspot2/OsuProviderTest.java b/wifi/tests/src/android/net/wifi/hotspot2/OsuProviderTest.java index 9670bfab89f8..d3f91f06da61 100644 --- a/wifi/tests/src/android/net/wifi/hotspot2/OsuProviderTest.java +++ b/wifi/tests/src/android/net/wifi/hotspot2/OsuProviderTest.java @@ -23,7 +23,7 @@ import android.graphics.drawable.Icon; import android.net.Uri; import android.net.wifi.WifiSsid; import android.os.Parcel; -import android.test.suitebuilder.annotation.SmallTest; +import android.support.test.filters.SmallTest; import org.junit.Test; diff --git a/wifi/tests/src/android/net/wifi/hotspot2/PasspointConfigurationTest.java b/wifi/tests/src/android/net/wifi/hotspot2/PasspointConfigurationTest.java index afcf3e344c27..940adc809535 100644 --- a/wifi/tests/src/android/net/wifi/hotspot2/PasspointConfigurationTest.java +++ b/wifi/tests/src/android/net/wifi/hotspot2/PasspointConfigurationTest.java @@ -25,7 +25,7 @@ import android.net.wifi.hotspot2.pps.HomeSp; import android.net.wifi.hotspot2.pps.Policy; import android.net.wifi.hotspot2.pps.UpdateParameter; import android.os.Parcel; -import android.test.suitebuilder.annotation.SmallTest; +import android.support.test.filters.SmallTest; import android.util.Base64; import org.junit.Test; diff --git a/wifi/tests/src/android/net/wifi/hotspot2/omadm/PpsMoParserTest.java b/wifi/tests/src/android/net/wifi/hotspot2/omadm/PpsMoParserTest.java index afa9fd6a9e8b..707b64f780c5 100644 --- a/wifi/tests/src/android/net/wifi/hotspot2/omadm/PpsMoParserTest.java +++ b/wifi/tests/src/android/net/wifi/hotspot2/omadm/PpsMoParserTest.java @@ -25,7 +25,7 @@ import android.net.wifi.hotspot2.pps.Credential; import android.net.wifi.hotspot2.pps.HomeSp; import android.net.wifi.hotspot2.pps.Policy; import android.net.wifi.hotspot2.pps.UpdateParameter; -import android.test.suitebuilder.annotation.SmallTest; +import android.support.test.filters.SmallTest; import android.text.TextUtils; import org.junit.Test; diff --git a/wifi/tests/src/android/net/wifi/hotspot2/omadm/XMLParserTest.java b/wifi/tests/src/android/net/wifi/hotspot2/omadm/XMLParserTest.java index c2dcec693b83..ef478c7a105c 100644 --- a/wifi/tests/src/android/net/wifi/hotspot2/omadm/XMLParserTest.java +++ b/wifi/tests/src/android/net/wifi/hotspot2/omadm/XMLParserTest.java @@ -20,7 +20,7 @@ import static org.junit.Assert.assertTrue; import android.net.wifi.hotspot2.omadm.XMLNode; import android.net.wifi.hotspot2.omadm.XMLParser; -import android.test.suitebuilder.annotation.SmallTest; +import android.support.test.filters.SmallTest; import org.junit.Before; import org.junit.Test; diff --git a/wifi/tests/src/android/net/wifi/hotspot2/pps/CredentialTest.java b/wifi/tests/src/android/net/wifi/hotspot2/pps/CredentialTest.java index 9bfc0105fcc9..b573adf60863 100644 --- a/wifi/tests/src/android/net/wifi/hotspot2/pps/CredentialTest.java +++ b/wifi/tests/src/android/net/wifi/hotspot2/pps/CredentialTest.java @@ -22,7 +22,7 @@ import static org.junit.Assert.assertTrue; import android.net.wifi.EAPConstants; import android.net.wifi.FakeKeys; import android.os.Parcel; -import android.test.suitebuilder.annotation.SmallTest; +import android.support.test.filters.SmallTest; import java.security.MessageDigest; import java.security.NoSuchAlgorithmException; diff --git a/wifi/tests/src/android/net/wifi/hotspot2/pps/HomeSpTest.java b/wifi/tests/src/android/net/wifi/hotspot2/pps/HomeSpTest.java index c41c11f16acf..5c9df6a0186c 100644 --- a/wifi/tests/src/android/net/wifi/hotspot2/pps/HomeSpTest.java +++ b/wifi/tests/src/android/net/wifi/hotspot2/pps/HomeSpTest.java @@ -20,7 +20,7 @@ import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertTrue; import android.os.Parcel; -import android.test.suitebuilder.annotation.SmallTest; +import android.support.test.filters.SmallTest; import org.junit.Test; diff --git a/wifi/tests/src/android/net/wifi/hotspot2/pps/PolicyTest.java b/wifi/tests/src/android/net/wifi/hotspot2/pps/PolicyTest.java index 2a3676463936..171d6ff0781f 100644 --- a/wifi/tests/src/android/net/wifi/hotspot2/pps/PolicyTest.java +++ b/wifi/tests/src/android/net/wifi/hotspot2/pps/PolicyTest.java @@ -20,7 +20,7 @@ import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertTrue; import android.os.Parcel; -import android.test.suitebuilder.annotation.SmallTest; +import android.support.test.filters.SmallTest; import android.util.Base64; import org.junit.Test; diff --git a/wifi/tests/src/android/net/wifi/hotspot2/pps/UpdateParameterTest.java b/wifi/tests/src/android/net/wifi/hotspot2/pps/UpdateParameterTest.java index 551ed43c5efa..2a7526bc3de6 100644 --- a/wifi/tests/src/android/net/wifi/hotspot2/pps/UpdateParameterTest.java +++ b/wifi/tests/src/android/net/wifi/hotspot2/pps/UpdateParameterTest.java @@ -20,7 +20,7 @@ import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertTrue; import android.os.Parcel; -import android.test.suitebuilder.annotation.SmallTest; +import android.support.test.filters.SmallTest; import android.util.Base64; import org.junit.Test; diff --git a/wifi/tests/src/android/net/wifi/p2p/WifiP2pManagerTest.java b/wifi/tests/src/android/net/wifi/p2p/WifiP2pManagerTest.java index 1e8382f9b045..e8e4dc2080c2 100644 --- a/wifi/tests/src/android/net/wifi/p2p/WifiP2pManagerTest.java +++ b/wifi/tests/src/android/net/wifi/p2p/WifiP2pManagerTest.java @@ -59,10 +59,10 @@ public class WifiP2pManagerTest { */ @Test public void testChannelFinalize() throws Exception { - WifiP2pManager.Channel channel = new WifiP2pManager.Channel(mContextMock, - mTestLooper.getLooper(), null, null, mDut); - - leakageDetectorRule.assertUnreleasedResourceCount(channel, 1); + try (WifiP2pManager.Channel channel = new WifiP2pManager.Channel(mContextMock, + mTestLooper.getLooper(), null, null, mDut)) { + leakageDetectorRule.assertUnreleasedResourceCount(channel, 1); + } } /** diff --git a/wifi/tests/src/android/net/wifi/rtt/WifiRttManagerTest.java b/wifi/tests/src/android/net/wifi/rtt/WifiRttManagerTest.java new file mode 100644 index 000000000000..41c7f8644e2e --- /dev/null +++ b/wifi/tests/src/android/net/wifi/rtt/WifiRttManagerTest.java @@ -0,0 +1,363 @@ +/* + * Copyright (C) 2017 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package android.net.wifi.rtt; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.verifyNoMoreInteractions; +import static org.mockito.Mockito.when; + +import android.content.Context; +import android.net.MacAddress; +import android.net.wifi.ScanResult; +import android.net.wifi.aware.PeerHandle; +import android.os.Handler; +import android.os.IBinder; +import android.os.Parcel; +import android.os.test.TestLooper; + +import org.junit.Before; +import org.junit.Test; +import org.mockito.ArgumentCaptor; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; + +import java.util.ArrayList; +import java.util.List; + +/** + * Unit test harness for WifiRttManager class. + */ +public class WifiRttManagerTest { + private WifiRttManager mDut; + private TestLooper mMockLooper; + private Handler mMockLooperHandler; + + private final String packageName = "some.package.name.for.rtt.app"; + + @Mock + public Context mockContext; + + @Mock + public IWifiRttManager mockRttService; + + @Before + public void setUp() throws Exception { + MockitoAnnotations.initMocks(this); + + mDut = new WifiRttManager(mockContext, mockRttService); + mMockLooper = new TestLooper(); + mMockLooperHandler = new Handler(mMockLooper.getLooper()); + + when(mockContext.getOpPackageName()).thenReturn(packageName); + } + + /** + * Validate ranging call flow with successful results. + */ + @Test + public void testRangeSuccess() throws Exception { + RangingRequest request = new RangingRequest.Builder().build(); + List<RangingResult> results = new ArrayList<>(); + results.add( + new RangingResult(RangingResult.STATUS_SUCCESS, MacAddress.BROADCAST_ADDRESS, 15, 5, + 10, null, null, 666)); + RangingResultCallback callbackMock = mock(RangingResultCallback.class); + ArgumentCaptor<IRttCallback> callbackCaptor = ArgumentCaptor.forClass(IRttCallback.class); + + // verify ranging request passed to service + mDut.startRanging(request, callbackMock, mMockLooperHandler); + verify(mockRttService).startRanging(any(IBinder.class), eq(packageName), eq(null), + eq(request), callbackCaptor.capture()); + + // service calls back with success + callbackCaptor.getValue().onRangingResults(results); + mMockLooper.dispatchAll(); + verify(callbackMock).onRangingResults(results); + + verifyNoMoreInteractions(mockRttService, callbackMock); + } + + /** + * Validate ranging call flow which failed. + */ + @Test + public void testRangeFail() throws Exception { + int failureCode = RangingResultCallback.STATUS_CODE_FAIL; + + RangingRequest request = new RangingRequest.Builder().build(); + RangingResultCallback callbackMock = mock(RangingResultCallback.class); + ArgumentCaptor<IRttCallback> callbackCaptor = ArgumentCaptor.forClass(IRttCallback.class); + + // verify ranging request passed to service + mDut.startRanging(request, callbackMock, mMockLooperHandler); + verify(mockRttService).startRanging(any(IBinder.class), eq(packageName), eq(null), + eq(request), callbackCaptor.capture()); + + // service calls back with failure code + callbackCaptor.getValue().onRangingFailure(failureCode); + mMockLooper.dispatchAll(); + verify(callbackMock).onRangingFailure(failureCode); + + verifyNoMoreInteractions(mockRttService, callbackMock); + } + + /** + * Validate that RangingRequest parcel works (produces same object on write/read). + */ + @Test + public void testRangingRequestParcel() { + // Note: not validating parcel code of ScanResult (assumed to work) + ScanResult scanResult1 = new ScanResult(); + scanResult1.BSSID = "00:01:02:03:04:05"; + ScanResult scanResult2 = new ScanResult(); + scanResult2.BSSID = "06:07:08:09:0A:0B"; + ScanResult scanResult3 = new ScanResult(); + scanResult3.BSSID = "AA:BB:CC:DD:EE:FF"; + List<ScanResult> scanResults2and3 = new ArrayList<>(2); + scanResults2and3.add(scanResult2); + scanResults2and3.add(scanResult3); + MacAddress mac1 = MacAddress.fromString("00:01:02:03:04:05"); + PeerHandle peerHandle1 = new PeerHandle(12); + + RangingRequest.Builder builder = new RangingRequest.Builder(); + builder.addAccessPoint(scanResult1); + builder.addAccessPoints(scanResults2and3); + builder.addWifiAwarePeer(mac1); + builder.addWifiAwarePeer(peerHandle1); + RangingRequest request = builder.build(); + + Parcel parcelW = Parcel.obtain(); + request.writeToParcel(parcelW, 0); + byte[] bytes = parcelW.marshall(); + parcelW.recycle(); + + Parcel parcelR = Parcel.obtain(); + parcelR.unmarshall(bytes, 0, bytes.length); + parcelR.setDataPosition(0); + RangingRequest rereadRequest = RangingRequest.CREATOR.createFromParcel(parcelR); + + assertEquals(request, rereadRequest); + } + + /** + * Validate that can request as many range operation as the upper limit on number of requests. + */ + @Test + public void testRangingRequestAtLimit() { + ScanResult scanResult = new ScanResult(); + scanResult.BSSID = "AA:BB:CC:DD:EE:FF"; + List<ScanResult> scanResultList = new ArrayList<>(); + for (int i = 0; i < RangingRequest.getMaxPeers() - 3; ++i) { + scanResultList.add(scanResult); + } + MacAddress mac1 = MacAddress.fromString("00:01:02:03:04:05"); + + // create request + RangingRequest.Builder builder = new RangingRequest.Builder(); + builder.addAccessPoint(scanResult); + builder.addAccessPoints(scanResultList); + builder.addAccessPoint(scanResult); + builder.addWifiAwarePeer(mac1); + RangingRequest request = builder.build(); + + // verify request + request.enforceValidity(true); + } + + /** + * Validate that limit on number of requests is applied. + */ + @Test(expected = IllegalArgumentException.class) + public void testRangingRequestPastLimit() { + ScanResult scanResult = new ScanResult(); + scanResult.BSSID = "00:01:02:03:04:05"; + List<ScanResult> scanResultList = new ArrayList<>(); + for (int i = 0; i < RangingRequest.getMaxPeers() - 2; ++i) { + scanResultList.add(scanResult); + } + MacAddress mac1 = MacAddress.fromString("00:01:02:03:04:05"); + + // create request + RangingRequest.Builder builder = new RangingRequest.Builder(); + builder.addAccessPoint(scanResult); + builder.addAccessPoints(scanResultList); + builder.addAccessPoint(scanResult); + builder.addWifiAwarePeer(mac1); + RangingRequest request = builder.build(); + + // verify request + request.enforceValidity(true); + } + + /** + * Validate that Aware requests are invalid on devices which do not support Aware + */ + @Test(expected = IllegalArgumentException.class) + public void testRangingRequestWithAwareWithNoAwareSupport() { + // create request + RangingRequest.Builder builder = new RangingRequest.Builder(); + builder.addWifiAwarePeer(new PeerHandle(10)); + RangingRequest request = builder.build(); + + // verify request + request.enforceValidity(false); + } + + /** + * Validate that RangingResults parcel works (produces same object on write/read). + */ + @Test + public void testRangingResultsParcel() { + // Note: not validating parcel code of ScanResult (assumed to work) + int status = RangingResult.STATUS_SUCCESS; + final MacAddress mac = MacAddress.fromString("00:01:02:03:04:05"); + PeerHandle peerHandle = new PeerHandle(10); + int distanceCm = 105; + int distanceStdDevCm = 10; + int rssi = 5; + long timestamp = System.currentTimeMillis(); + double latitude = 5.5; + double latitudeUncertainty = 6.5; + double longitude = 7.5; + double longitudeUncertainty = 8.5; + int altitudeType = LocationConfigurationInformation.ALTITUDE_IN_METERS; + double altitude = 9.5; + double altitudeUncertainty = 55.5; + byte[] lcrData = { 0x1, 0x2, 0x3, 0xA, 0xB, 0xC }; + + LocationConfigurationInformation lci = new LocationConfigurationInformation(latitude, + latitudeUncertainty, longitude, longitudeUncertainty, altitudeType, altitude, + altitudeUncertainty); + LocationCivic lcr = new LocationCivic(lcrData); + + // RangingResults constructed with a MAC address + RangingResult result = new RangingResult(status, mac, distanceCm, distanceStdDevCm, rssi, + lci, lcr, timestamp); + + Parcel parcelW = Parcel.obtain(); + result.writeToParcel(parcelW, 0); + byte[] bytes = parcelW.marshall(); + parcelW.recycle(); + + Parcel parcelR = Parcel.obtain(); + parcelR.unmarshall(bytes, 0, bytes.length); + parcelR.setDataPosition(0); + RangingResult rereadResult = RangingResult.CREATOR.createFromParcel(parcelR); + + assertEquals(result, rereadResult); + + // RangingResults constructed with a PeerHandle + result = new RangingResult(status, peerHandle, distanceCm, distanceStdDevCm, rssi, + null, null, timestamp); + + parcelW = Parcel.obtain(); + result.writeToParcel(parcelW, 0); + bytes = parcelW.marshall(); + parcelW.recycle(); + + parcelR = Parcel.obtain(); + parcelR.unmarshall(bytes, 0, bytes.length); + parcelR.setDataPosition(0); + rereadResult = RangingResult.CREATOR.createFromParcel(parcelR); + + assertEquals(result, rereadResult); + } + + /** + * Validate that LocationConfigurationInformation parcel works (produces same object on + * write/read). + */ + @Test + public void testLciParcel() { + double latitude = 1.5; + double latitudeUncertainty = 2.5; + double longitude = 3.5; + double longitudeUncertainty = 4.5; + int altitudeType = LocationConfigurationInformation.ALTITUDE_IN_FLOORS; + double altitude = 5.5; + double altitudeUncertainty = 6.5; + + LocationConfigurationInformation lci = new LocationConfigurationInformation(latitude, + latitudeUncertainty, longitude, longitudeUncertainty, altitudeType, altitude, + altitudeUncertainty); + + Parcel parcelW = Parcel.obtain(); + lci.writeToParcel(parcelW, 0); + byte[] bytes = parcelW.marshall(); + parcelW.recycle(); + + Parcel parcelR = Parcel.obtain(); + parcelR.unmarshall(bytes, 0, bytes.length); + parcelR.setDataPosition(0); + LocationConfigurationInformation rereadLci = + LocationConfigurationInformation.CREATOR.createFromParcel(parcelR); + + assertEquals(lci, rereadLci); + } + + /** + * Validate that the LCI throws an exception when accessing invalid fields an certain altitude + * types. + */ + @Test + public void testLciInvalidAltitudeFieldAccess() { + boolean exceptionThrown; + LocationConfigurationInformation lci = new LocationConfigurationInformation(0, 0, 0, 0, + LocationConfigurationInformation.ALTITUDE_UNKNOWN, 0, 0); + + // UNKNOWN - invalid altitude & altitude uncertainty + exceptionThrown = false; + try { + lci.getAltitude(); + } catch (IllegalStateException e) { + exceptionThrown = true; + } + assertTrue("UNKNOWN / getAltitude()", exceptionThrown); + + exceptionThrown = false; + try { + lci.getAltitudeUncertainty(); + } catch (IllegalStateException e) { + exceptionThrown = true; + } + assertTrue("UNKNOWN / getAltitudeUncertainty()", exceptionThrown); + + lci = new LocationConfigurationInformation(0, 0, 0, 0, + LocationConfigurationInformation.ALTITUDE_IN_FLOORS, 0, 0); + + // FLOORS - invalid altitude uncertainty + exceptionThrown = false; + try { + lci.getAltitudeUncertainty(); + } catch (IllegalStateException e) { + exceptionThrown = true; + } + assertTrue("FLOORS / getAltitudeUncertainty()", exceptionThrown); + + // and good accesses just in case + lci.getAltitude(); + lci = new LocationConfigurationInformation(0, 0, 0, 0, + LocationConfigurationInformation.ALTITUDE_IN_METERS, 0, 0); + lci.getAltitude(); + lci.getAltitudeUncertainty(); + } +} |