ScanTestUtil.java revision 41e38d84f562e12198f7db0d45f633712cae6cba 
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.*;
20import static org.mockito.Mockito.when;
21
22import android.net.wifi.ScanResult;
23import android.net.wifi.WifiScanner;
24import android.net.wifi.WifiScanner.ChannelSpec;
25import android.net.wifi.WifiScanner.ScanData;
26import android.net.wifi.WifiScanner.ScanSettings;
27import android.net.wifi.WifiSsid;
28
29import com.android.server.wifi.WifiNative.BucketSettings;
30
31import java.lang.reflect.Field;
32import java.util.Arrays;
33import java.util.HashSet;
34import java.util.Set;
35
36/**
37 * Utilities for testing Wifi Scanning
38 */
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    public static class NativeScanSettingsBuilder {
86        private final WifiNative.ScanSettings settings = new WifiNative.ScanSettings();
87        public NativeScanSettingsBuilder() {
88            settings.buckets = new WifiNative.BucketSettings[0];
89            settings.num_buckets = 0;
90            settings.report_threshold_percent = 100;
91        }
92
93        public NativeScanSettingsBuilder withBasePeriod(int basePeriod) {
94            settings.base_period_ms = basePeriod;
95            return this;
96        }
97        public NativeScanSettingsBuilder withMaxApPerScan(int maxAp) {
98            settings.max_ap_per_scan = maxAp;
99            return this;
100        }
101        public NativeScanSettingsBuilder withMaxScansToCache(int maxScans) {
102            settings.report_threshold_num_scans = maxScans;
103            return this;
104        }
105
106        public NativeScanSettingsBuilder addBucketWithBand(
107                int period, int report_events, int band) {
108            WifiNative.BucketSettings bucket = new WifiNative.BucketSettings();
109            bucket.bucket = settings.num_buckets;
110            bucket.band = band;
111            bucket.period_ms = period;
112            bucket.report_events = report_events;
113            return addBucket(bucket);
114        }
115
116        public NativeScanSettingsBuilder addBucketWithChannels(
117                int period, int report_events, int... channels) {
118            WifiNative.BucketSettings bucket = new WifiNative.BucketSettings();
119            bucket.bucket = settings.num_buckets;
120            bucket.band = WifiScanner.WIFI_BAND_UNSPECIFIED;
121            bucket.num_channels = channels.length;
122            bucket.channels = new WifiNative.ChannelSettings[channels.length];
123            for (int i = 0; i < channels.length; ++i) {
124                bucket.channels[i] = new WifiNative.ChannelSettings();
125                bucket.channels[i].frequency = channels[i];
126            }
127            bucket.period_ms = period;
128            bucket.report_events = report_events;
129            return addBucket(bucket);
130        }
131
132        public NativeScanSettingsBuilder addBucket(WifiNative.BucketSettings bucket) {
133            settings.buckets = Arrays.copyOf(settings.buckets, settings.num_buckets + 1);
134            settings.buckets[settings.num_buckets] = bucket;
135            settings.num_buckets = settings.num_buckets + 1;
136            return this;
137        }
138
139        public WifiNative.ScanSettings build() {
140            return settings;
141        }
142    }
143
144    public static Set<Integer> createFreqSet(int... elements) {
145        Set<Integer> set = new HashSet<>();
146        for (int e : elements) {
147            set.add(e);
148        }
149        return set;
150    }
151
152    public static ScanResult createScanResult(int freq) {
153        return new ScanResult(WifiSsid.createFromAsciiEncoded("AN SSID"), "00:00:00:00:00:00", "",
154                0, freq, 0);
155    }
156
157    public static ScanData createScanData(int... freqs) {
158        ScanResult[] results = new ScanResult[freqs.length];
159        for (int i = 0; i < freqs.length; ++i) {
160            results[i] = createScanResult(freqs[i]);
161        }
162        return new ScanData(0, 0, results);
163    }
164
165    public static ScanData[] createScanDatas(int[][] freqs) {
166        ScanData[] data = new ScanData[freqs.length];
167        for (int i = 0; i < freqs.length; ++i) {
168            data[i] = createScanData(freqs[i]);
169        }
170        return data;
171    }
172
173    public static void assertScanDatasEquals(ScanData[] expected, ScanData[] actual) {
174        assertNotNull(expected);
175        assertNotNull(actual);
176        assertEquals("ScanData.length", expected.length, actual.length);
177        for (int i = 0; i < expected.length; ++i) {
178            ScanData expectedData = expected[i];
179            ScanData actualData = actual[i];
180            assertEquals("ScanData["+i+"].id", expectedData.getId(), actualData.getId());
181            assertEquals("ScanData["+i+"].flags", expectedData.getFlags(), actualData.getFlags());
182            assertEquals("ScanData["+i+"].results.length",
183                    expectedData.getResults().length, actualData.getResults().length);
184            for (int j = 0; j < expectedData.getResults().length; ++ j) {
185                ScanResult expectedResult = expectedData.getResults()[j];
186                ScanResult actualResult = actualData.getResults()[j];
187                assertEquals("ScanData["+i+"].results["+j+"].SSID",
188                        expectedResult.SSID, actualResult.SSID);
189                assertEquals("ScanData["+i+"].results["+j+"].wifiSsid",
190                        expectedResult.wifiSsid.toString(), actualResult.wifiSsid.toString());
191                assertEquals("ScanData["+i+"].results["+j+"].BSSID",
192                        expectedResult.BSSID, actualResult.BSSID);
193                assertEquals("ScanData["+i+"].results["+j+"].capabilities",
194                        expectedResult.capabilities, actualResult.capabilities);
195                assertEquals("ScanData["+i+"].results["+j+"].level",
196                        expectedResult.level, actualResult.level);
197                assertEquals("ScanData["+i+"].results["+j+"].frequency",
198                        expectedResult.frequency, actualResult.frequency);
199                assertEquals("ScanData["+i+"].results["+j+"].timestamp",
200                        expectedResult.timestamp, actualResult.timestamp);
201                assertEquals("ScanData["+i+"].results["+j+"].frequency",
202                        expectedResult.seen, actualResult.seen);
203            }
204        }
205    }
206
207    public static WifiScanner.ChannelSpec[] channelsToSpec(int... channels) {
208        WifiScanner.ChannelSpec[] channelSpecs = new WifiScanner.ChannelSpec[channels.length];
209        for (int i = 0; i < channels.length; ++i) {
210            channelSpecs[i] = new WifiScanner.ChannelSpec(channels[i]);
211        }
212        return channelSpecs;
213    }
214
215    public static ChannelSpec[] getAllChannels(BucketSettings bucket) {
216        if (bucket.band == WifiScanner.WIFI_BAND_UNSPECIFIED) {
217            ChannelSpec[] channels = new ChannelSpec[bucket.num_channels];
218            for (int i = 0; i < bucket.num_channels; i++) {
219                channels[i] = new ChannelSpec(bucket.channels[i].frequency);
220            }
221            return channels;
222        } else {
223            return WifiChannelHelper.getChannelsForBand(bucket.band);
224        }
225    }
226    public static ChannelSpec[] getAllChannels(ScanSettings settings) {
227        if (settings.band == WifiScanner.WIFI_BAND_UNSPECIFIED) {
228            ChannelSpec[] channels = new ChannelSpec[settings.channels.length];
229            for (int i = 0; i < settings.channels.length; i++) {
230                channels[i] = new ChannelSpec(settings.channels[i].frequency);
231            }
232            return channels;
233        } else {
234            return WifiChannelHelper.getChannelsForBand(settings.band);
235        }
236    }
237}
238