ScanScheduleUtilFilterTest.java revision 1a16020f8d611c94797884b212ee6a26817fad82 
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 com.android.server.wifi.ScanTestUtil.channelsToSpec;
20import static com.android.server.wifi.ScanTestUtil.createRequest;
21import static com.android.server.wifi.ScanTestUtil.createScanDatas;
22import static com.android.server.wifi.ScanTestUtil.createScanResult;
23import static com.android.server.wifi.ScanTestUtil.installWlanWifiNative;
24import static com.android.server.wifi.ScanTestUtil.setupMockChannels;
25
26import static org.junit.Assert.assertEquals;
27import static org.junit.Assert.assertFalse;
28import static org.junit.Assert.assertNotNull;
29import static org.junit.Assert.assertNull;
30import static org.junit.Assert.assertTrue;
31import static org.mockito.Mockito.mock;
32
33import android.net.wifi.WifiScanner;
34import android.net.wifi.WifiScanner.ScanData;
35import android.net.wifi.WifiScanner.ScanSettings;
36import android.test.suitebuilder.annotation.SmallTest;
37
38import org.junit.Before;
39import org.junit.Test;
40
41import java.util.Collection;
42import java.util.Collections;
43
44/**
45 * Unit tests for filtering of scan results in {@link com.android.server.wifi.MultiClientScheduler}.
46 */
47@SmallTest
48public class MultiClientSchedulerFilterTest {
49
50    private static final int DEFAULT_MAX_BUCKETS = 8;
51    private static final int DEFAULT_MAX_CHANNELS = 8;
52    private static final int DEFAULT_MAX_BATCH = 10;
53
54    private WifiNative mWifiNative;
55    private MultiClientScheduler mScheduler;
56
57    @Before
58    public void setUp() throws Exception {
59        mWifiNative = mock(WifiNative.class);
60        setupMockChannels(mWifiNative,
61                new int[]{2400, 2450},
62                new int[]{5150, 5175},
63                new int[]{5600, 5650});
64        installWlanWifiNative(mWifiNative);
65
66        mScheduler = new MultiClientScheduler();
67        mScheduler.setMaxBuckets(DEFAULT_MAX_BUCKETS);
68        mScheduler.setMaxChannels(DEFAULT_MAX_CHANNELS);
69        mScheduler.setMaxBatch(DEFAULT_MAX_BATCH);
70    }
71
72    @Test
73    public void reportFullResultTrueForBands() {
74        ScanSettings settings = createRequest(
75                WifiScanner.WIFI_BAND_24_GHZ, 30000, 0, 20,
76                WifiScanner.REPORT_EVENT_FULL_SCAN_RESULT
77        );
78        Collection<ScanSettings> requests = Collections.singleton(settings);
79        mScheduler.updateSchedule(requests);
80
81        assertTrue(mScheduler.shouldReportFullScanResultForSettings(
82                createScanResult(2400), settings));
83    }
84
85    @Test
86    public void reportFullResultFalseForBands() {
87        ScanSettings settings = createRequest(
88                WifiScanner.WIFI_BAND_24_GHZ, 30000, 0, 20,
89                WifiScanner.REPORT_EVENT_FULL_SCAN_RESULT
90        );
91        Collection<ScanSettings> requests = Collections.singleton(settings);
92        mScheduler.updateSchedule(requests);
93
94        assertFalse(mScheduler.shouldReportFullScanResultForSettings(
95                createScanResult(5150), settings));
96    }
97
98    @Test
99    public void reportFullResultTrueForChannels() {
100        ScanSettings settings = createRequest(
101                channelsToSpec(2400, 5150), 30000, 0, 20,
102                WifiScanner.REPORT_EVENT_FULL_SCAN_RESULT
103        );
104        Collection<ScanSettings> requests = Collections.singleton(settings);
105        mScheduler.updateSchedule(requests);
106
107        assertTrue(mScheduler.shouldReportFullScanResultForSettings(
108                createScanResult(2400), settings));
109    }
110
111    @Test
112    public void reportFullResultFalseForChannels() {
113        ScanSettings settings = createRequest(
114                channelsToSpec(2400, 5150), 30000, 0, 20,
115                WifiScanner.REPORT_EVENT_FULL_SCAN_RESULT
116        );
117        Collection<ScanSettings> requests = Collections.singleton(settings);
118        mScheduler.updateSchedule(requests);
119
120        assertFalse(mScheduler.shouldReportFullScanResultForSettings(
121                createScanResult(5175), settings));
122    }
123
124    @Test
125    public void filterScanDataEmpty() {
126        ScanSettings settings = createRequest(
127                channelsToSpec(2400, 5150), 30000, 0, 20,
128                WifiScanner.REPORT_EVENT_FULL_SCAN_RESULT
129        );
130        Collection<ScanSettings> requests = Collections.singleton(settings);
131        mScheduler.updateSchedule(requests);
132
133        ScanData[] results = mScheduler.filterResultsForSettings(new ScanData[0], settings);
134        assertScanDataFreqsEquals(null, results);
135    }
136
137    @Test
138    public void filterScanDataSingleNotMatching() {
139        ScanSettings settings = createRequest(
140                channelsToSpec(2400, 5150), 30000, 0, 20,
141                WifiScanner.REPORT_EVENT_FULL_SCAN_RESULT
142        );
143        Collection<ScanSettings> requests = Collections.singleton(settings);
144        mScheduler.updateSchedule(requests);
145
146        ScanData[] results = mScheduler.filterResultsForSettings(
147                createScanDatas(new int[][]{ { 2450 } }), settings);
148        assertScanDataFreqsEquals(null, results);
149    }
150
151    @Test
152    public void filterScanDataSingleMatching() {
153        ScanSettings settings = createRequest(
154                channelsToSpec(2400, 5150), 30000, 0, 20,
155                WifiScanner.REPORT_EVENT_FULL_SCAN_RESULT
156        );
157        Collection<ScanSettings> requests = Collections.singleton(settings);
158        mScheduler.updateSchedule(requests);
159
160        ScanData[] results = mScheduler.filterResultsForSettings(
161                createScanDatas(new int[][]{ { 2400 } }), settings);
162
163        assertScanDataFreqsEquals(new int[][]{ { 2400 } }, results);
164    }
165
166    @Test
167    public void filterScanDataSinglePartialMatching() {
168        ScanSettings settings = createRequest(
169                channelsToSpec(2400, 5150), 30000, 0, 20,
170                WifiScanner.REPORT_EVENT_FULL_SCAN_RESULT
171        );
172        Collection<ScanSettings> requests = Collections.singleton(settings);
173        mScheduler.updateSchedule(requests);
174
175        ScanData[] results = mScheduler.filterResultsForSettings(
176                createScanDatas(new int[][]{ { 2400, 2450, 5150, 5175 } }), settings);
177
178        assertScanDataFreqsEquals(new int[][]{ { 2400, 5150 } }, results);
179    }
180
181    @Test
182    public void filterScanDataMultipleNotMatching() {
183        ScanSettings settings = createRequest(
184                channelsToSpec(2400, 5150), 30000, 0, 20,
185                WifiScanner.REPORT_EVENT_FULL_SCAN_RESULT
186        );
187        Collection<ScanSettings> requests = Collections.singleton(settings);
188        mScheduler.updateSchedule(requests);
189
190        ScanData[] results = mScheduler.filterResultsForSettings(
191                createScanDatas(new int[][]{ { 2450 }, { 2450, 5175 } }), settings);
192        assertScanDataFreqsEquals(null, results);
193    }
194
195    @Test
196    public void filterScanDataMultipleMatching() {
197        ScanSettings settings = createRequest(
198                channelsToSpec(2400, 5150), 30000, 0, 20,
199                WifiScanner.REPORT_EVENT_FULL_SCAN_RESULT
200        );
201        Collection<ScanSettings> requests = Collections.singleton(settings);
202        mScheduler.updateSchedule(requests);
203
204        ScanData[] results = mScheduler.filterResultsForSettings(
205                createScanDatas(new int[][]{ { 2400 }, {2400, 5150} }), settings);
206
207        assertScanDataFreqsEquals(new int[][]{ { 2400 }, {2400, 5150} }, results);
208    }
209
210    @Test
211    public void filterScanDataMultiplePartialMatching() {
212        ScanSettings settings = createRequest(
213                channelsToSpec(2400, 5150), 30000, 0, 20,
214                WifiScanner.REPORT_EVENT_FULL_SCAN_RESULT
215        );
216        Collection<ScanSettings> requests = Collections.singleton(settings);
217        mScheduler.updateSchedule(requests);
218
219        ScanData[] results = mScheduler.filterResultsForSettings(createScanDatas(
220                new int[][]{ { 2400, 2450, 5150, 5175 }, { 2400, 2450, 5175 } }), settings);
221
222        assertScanDataFreqsEquals(new int[][]{ { 2400, 5150 }, { 2400 } }, results);
223    }
224
225    @Test
226    public void filterScanDataMultipleDuplicateFrequencies() {
227        ScanSettings settings = createRequest(
228                channelsToSpec(2400, 5150), 30000, 0, 20,
229                WifiScanner.REPORT_EVENT_FULL_SCAN_RESULT
230        );
231        Collection<ScanSettings> requests = Collections.singleton(settings);
232        mScheduler.updateSchedule(requests);
233
234        ScanData[] results = mScheduler.filterResultsForSettings(createScanDatas(
235                new int[][]{ { 2400, 2450, 5150, 5175, 2400 },
236                             { 2400, 2450, 5175 },
237                             { 5175, 5175, 5150 } }), settings);
238
239        assertScanDataFreqsEquals(new int[][]{ { 2400, 5150, 2400 }, { 2400 }, { 5150 } }, results);
240    }
241
242    @Test
243    public void filterScanDataMultipleSomeNotMatching() {
244        ScanSettings settings = createRequest(
245                channelsToSpec(2400, 5150), 30000, 0, 20,
246                WifiScanner.REPORT_EVENT_FULL_SCAN_RESULT
247        );
248        Collection<ScanSettings> requests = Collections.singleton(settings);
249        mScheduler.updateSchedule(requests);
250
251        ScanData[] results = mScheduler.filterResultsForSettings(createScanDatas(
252                new int[][]{ { 2400, 2450, 5150, 5175, 2400 },
253                             { 5175 },
254                             { 5175, 5175, 5150 } }), settings);
255
256        assertScanDataFreqsEquals(new int[][]{ { 2400, 5150, 2400 }, { 5150 } }, results);
257    }
258
259    @Test
260    public void filterScanDataExceedMaxBssidsPerScan() {
261        ScanSettings settings = createRequest(
262                channelsToSpec(2400, 5150), 30000, 0, 3,
263                WifiScanner.REPORT_EVENT_FULL_SCAN_RESULT
264        );
265        Collection<ScanSettings> requests = Collections.singleton(settings);
266        mScheduler.updateSchedule(requests);
267
268        ScanData[] results = mScheduler.filterResultsForSettings(createScanDatas(
269                        new int[][]{ { 2400, 2450, 5150, 5175, 2400, 2400},
270                                     { 5175 },
271                                     { 5175, 5175, 5150, 2400, 2400, 5150 } }), settings);
272
273        assertScanDataFreqsEquals(new int[][]{ { 2400, 5150, 2400 }, { 5150, 2400, 2400 } },
274                results);
275    }
276
277
278    public static void assertScanDataFreqsEquals(int[][] expected, ScanData[] results) {
279        if (expected == null) {
280            assertNull(results);
281        } else {
282            assertNotNull(results);
283            assertEquals("num scans", expected.length, results.length);
284            for (int i = 0; i < expected.length; ++i) {
285                assertNotNull("scan[" + i + "] was null", results[i]);
286                assertEquals("num aps in scan[" + i + "]", expected[i].length,
287                        results[i].getResults().length);
288                for (int j = 0; j < expected[i].length; ++j) {
289                    assertNotNull("ap result[" + i + "][" + j + "] was null",
290                            results[i].getResults()[j]);
291                    assertEquals("ap freq in result[" + i + "][" + j + "]", expected[i][j],
292                            results[i].getResults()[j].frequency);
293                }
294            }
295        }
296    }
297}
298