ScanTestUtil.java revision 2771787818003e53e8175036a3d09688c783f350 
1/*
2 * Copyright (C) 2015 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License
15 */
16
17package com.android.server.wifi;
18
19import static org.junit.Assert.assertEquals;
20import static org.junit.Assert.assertNotNull;
21import static org.mockito.Mockito.when;
22
23import android.net.wifi.ScanResult;
24import android.net.wifi.WifiScanner;
25import android.net.wifi.WifiScanner.ChannelSpec;
26import android.net.wifi.WifiScanner.ScanData;
27import android.net.wifi.WifiScanner.ScanSettings;
28import android.net.wifi.WifiSsid;
29
30import com.android.server.wifi.WifiNative.BucketSettings;
31
32import java.lang.reflect.Field;
33import java.util.Arrays;
34import java.util.HashSet;
35import java.util.Set;
36
37/**
38 * Utilities for testing Wifi Scanning
39 */
40public class ScanTestUtil {
41
42    public static void installWlanWifiNative(WifiNative wifiNative) throws Exception {
43        Field field = WifiNative.class.getDeclaredField("wlanNativeInterface");
44        field.setAccessible(true);
45        field.set(null, wifiNative);
46
47        // Clear static state
48        WifiChannelHelper.clearChannelCache();
49    }
50
51    public static void setupMockChannels(WifiNative wifiNative, int[] channels24, int[] channels5,
52            int[] channelsDfs) throws Exception {
53        when(wifiNative.getChannelsForBand(WifiScanner.WIFI_BAND_24_GHZ))
54                .thenReturn(channels24);
55        when(wifiNative.getChannelsForBand(WifiScanner.WIFI_BAND_5_GHZ))
56                .thenReturn(channels5);
57        when(wifiNative.getChannelsForBand(WifiScanner.WIFI_BAND_5_GHZ_DFS_ONLY))
58                .thenReturn(channelsDfs);
59    }
60
61    public static ScanSettings createRequest(WifiScanner.ChannelSpec[] channels, int period,
62            int batch, int bssidsPerScan, int reportEvents) {
63        ScanSettings request = new ScanSettings();
64        request.band = WifiScanner.WIFI_BAND_UNSPECIFIED;
65        request.channels = channels;
66        request.periodInMs = period;
67        request.numBssidsPerScan = bssidsPerScan;
68        request.maxScansToCache = batch;
69        request.reportEvents = reportEvents;
70        return request;
71    }
72
73    public static ScanSettings createRequest(int band, int period, int batch, int bssidsPerScan,
74            int reportEvents) {
75        ScanSettings request = new ScanSettings();
76        request.band = band;
77        request.channels = null;
78        request.periodInMs = period;
79        request.numBssidsPerScan = bssidsPerScan;
80        request.maxScansToCache = batch;
81        request.reportEvents = reportEvents;
82        return request;
83    }
84
85    /**
86     * Create an exponential back off scan request if maxPeriod != period && maxPeriod != 0.
87     */
88    public static ScanSettings createRequest(int band, int period, int maxPeriod, int stepCount,
89            int batch, int bssidsPerScan, int reportEvents) {
90        ScanSettings request = new ScanSettings();
91        request.band = band;
92        request.channels = null;
93        request.periodInMs = period;
94        request.maxPeriodInMs = maxPeriod;
95        request.stepCount = stepCount;
96        request.numBssidsPerScan = bssidsPerScan;
97        request.maxScansToCache = batch;
98        request.reportEvents = reportEvents;
99        return request;
100    }
101
102    /**
103     * Builder to create WifiNative.ScanSettings objects for testing
104     */
105    public static class NativeScanSettingsBuilder {
106        private final WifiNative.ScanSettings mSettings = new WifiNative.ScanSettings();
107        public NativeScanSettingsBuilder() {
108            mSettings.buckets = new WifiNative.BucketSettings[0];
109            mSettings.num_buckets = 0;
110            mSettings.report_threshold_percent = 100;
111        }
112
113        public NativeScanSettingsBuilder withBasePeriod(int basePeriod) {
114            mSettings.base_period_ms = basePeriod;
115            return this;
116        }
117        public NativeScanSettingsBuilder withMaxApPerScan(int maxAp) {
118            mSettings.max_ap_per_scan = maxAp;
119            return this;
120        }
121        public NativeScanSettingsBuilder withMaxScansToCache(int maxScans) {
122            mSettings.report_threshold_num_scans = maxScans;
123            return this;
124        }
125
126        public NativeScanSettingsBuilder addBucketWithBand(
127                int period, int reportEvents, int band) {
128            WifiNative.BucketSettings bucket = new WifiNative.BucketSettings();
129            bucket.bucket = mSettings.num_buckets;
130            bucket.band = band;
131            bucket.period_ms = period;
132            bucket.report_events = reportEvents;
133            return addBucket(bucket);
134        }
135
136        public NativeScanSettingsBuilder addBucketWithChannels(
137                int period, int reportEvents, int... channels) {
138            WifiNative.BucketSettings bucket = new WifiNative.BucketSettings();
139            bucket.bucket = mSettings.num_buckets;
140            bucket.band = WifiScanner.WIFI_BAND_UNSPECIFIED;
141            bucket.num_channels = channels.length;
142            bucket.channels = new WifiNative.ChannelSettings[channels.length];
143            for (int i = 0; i < channels.length; ++i) {
144                bucket.channels[i] = new WifiNative.ChannelSettings();
145                bucket.channels[i].frequency = channels[i];
146            }
147            bucket.period_ms = period;
148            bucket.report_events = reportEvents;
149            return addBucket(bucket);
150        }
151
152        public NativeScanSettingsBuilder addBucket(WifiNative.BucketSettings bucket) {
153            mSettings.buckets = Arrays.copyOf(mSettings.buckets, mSettings.num_buckets + 1);
154            mSettings.buckets[mSettings.num_buckets] = bucket;
155            mSettings.num_buckets = mSettings.num_buckets + 1;
156            return this;
157        }
158
159        public WifiNative.ScanSettings build() {
160            return mSettings;
161        }
162    }
163
164    public static Set<Integer> createFreqSet(int... elements) {
165        Set<Integer> set = new HashSet<>();
166        for (int e : elements) {
167            set.add(e);
168        }
169        return set;
170    }
171
172    public static ScanResult createScanResult(int freq) {
173        return new ScanResult(WifiSsid.createFromAsciiEncoded("AN SSID"), "00:00:00:00:00:00", "",
174                0, freq, 0);
175    }
176
177    public static ScanData createScanData(int... freqs) {
178        ScanResult[] results = new ScanResult[freqs.length];
179        for (int i = 0; i < freqs.length; ++i) {
180            results[i] = createScanResult(freqs[i]);
181        }
182        return new ScanData(0, 0, results);
183    }
184
185    public static ScanData[] createScanDatas(int[][] freqs) {
186        ScanData[] data = new ScanData[freqs.length];
187        for (int i = 0; i < freqs.length; ++i) {
188            data[i] = createScanData(freqs[i]);
189        }
190        return data;
191    }
192
193    private static void assertScanDataEquals(String prefix, ScanData expected, ScanData actual) {
194        assertNotNull(prefix + "expected ScanData was null", expected);
195        assertNotNull(prefix + "actual ScanData was null", actual);
196        assertEquals(prefix + "id", expected.getId(), actual.getId());
197        assertEquals(prefix + "flags", expected.getFlags(), actual.getFlags());
198        assertEquals(prefix + "results.length",
199                expected.getResults().length, actual.getResults().length);
200        for (int j = 0; j < expected.getResults().length; ++j) {
201            ScanResult expectedResult = expected.getResults()[j];
202            ScanResult actualResult = actual.getResults()[j];
203            assertEquals(prefix + "results[" + j + "].SSID",
204                    expectedResult.SSID, actualResult.SSID);
205            assertEquals(prefix + "results[" + j + "].wifiSsid",
206                    expectedResult.wifiSsid.toString(), actualResult.wifiSsid.toString());
207            assertEquals(prefix + "results[" + j + "].BSSID",
208                    expectedResult.BSSID, actualResult.BSSID);
209            assertEquals(prefix + "results[" + j + "].capabilities",
210                    expectedResult.capabilities, actualResult.capabilities);
211            assertEquals(prefix + "results[" + j + "].level",
212                    expectedResult.level, actualResult.level);
213            assertEquals(prefix + "results[" + j + "].frequency",
214                    expectedResult.frequency, actualResult.frequency);
215            assertEquals(prefix + "results[" + j + "].timestamp",
216                    expectedResult.timestamp, actualResult.timestamp);
217            assertEquals(prefix + "results[" + j + "].seen",
218                    expectedResult.seen, actualResult.seen);
219        }
220    }
221
222    public static void assertScanDataEquals(ScanData expected, ScanData actual) {
223        assertScanDataEquals("", expected, actual);
224    }
225
226    public static void assertScanDatasEquals(String prefix, ScanData[] expected, ScanData[] actual) {
227        assertNotNull("expected " + prefix + "ScanData[] was null", expected);
228        assertNotNull("actaul " + prefix + "ScanData[] was null", actual);
229        assertEquals(prefix + "ScanData.length", expected.length, actual.length);
230        for (int i = 0; i < expected.length; ++i) {
231            assertScanDataEquals(prefix + "ScanData[" + i + "].", expected[i], actual[i]);
232        }
233    }
234
235    public static void assertScanDatasEquals(ScanData[] expected, ScanData[] actual) {
236        assertScanDatasEquals("", expected, actual);
237    }
238
239    public static WifiScanner.ChannelSpec[] channelsToSpec(int... channels) {
240        WifiScanner.ChannelSpec[] channelSpecs = new WifiScanner.ChannelSpec[channels.length];
241        for (int i = 0; i < channels.length; ++i) {
242            channelSpecs[i] = new WifiScanner.ChannelSpec(channels[i]);
243        }
244        return channelSpecs;
245    }
246
247    public static ChannelSpec[] getAllChannels(BucketSettings bucket) {
248        if (bucket.band == WifiScanner.WIFI_BAND_UNSPECIFIED) {
249            ChannelSpec[] channels = new ChannelSpec[bucket.num_channels];
250            for (int i = 0; i < bucket.num_channels; i++) {
251                channels[i] = new ChannelSpec(bucket.channels[i].frequency);
252            }
253            return channels;
254        } else {
255            return WifiChannelHelper.getChannelsForBand(bucket.band);
256        }
257    }
258    public static ChannelSpec[] getAllChannels(ScanSettings settings) {
259        if (settings.band == WifiScanner.WIFI_BAND_UNSPECIFIED) {
260            ChannelSpec[] channels = new ChannelSpec[settings.channels.length];
261            for (int i = 0; i < settings.channels.length; i++) {
262                channels[i] = new ChannelSpec(settings.channels[i].frequency);
263            }
264            return channels;
265        } else {
266            return WifiChannelHelper.getChannelsForBand(settings.band);
267        }
268    }
269}
270