1/*
2 * Copyright (C) 2016 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.nan;
18
19import static org.hamcrest.core.IsEqual.equalTo;
20import static org.junit.Assert.assertEquals;
21
22import android.net.wifi.nan.ConfigRequest;
23import android.net.wifi.nan.PublishData;
24import android.net.wifi.nan.PublishSettings;
25import android.net.wifi.nan.SubscribeData;
26import android.net.wifi.nan.SubscribeSettings;
27import android.os.Parcel;
28import android.test.suitebuilder.annotation.SmallTest;
29
30import org.junit.Rule;
31import org.junit.Test;
32import org.junit.rules.ErrorCollector;
33import org.junit.rules.ExpectedException;
34
35/**
36 * Unit test harness for WifiNanManager class.
37 */
38@SmallTest
39public class WifiNanManagerTest {
40    @Rule
41    public ErrorCollector collector = new ErrorCollector();
42
43    @Rule
44    public ExpectedException thrown = ExpectedException.none();
45
46    /*
47     * ConfigRequest Tests
48     */
49
50    @Test
51    public void testConfigRequestBuilder() {
52        final int clusterHigh = 100;
53        final int clusterLow = 5;
54        final int masterPreference = 55;
55        final boolean supportBand5g = true;
56
57        ConfigRequest configRequest = new ConfigRequest.Builder().setClusterHigh(clusterHigh)
58                .setClusterLow(clusterLow).setMasterPreference(masterPreference)
59                .setSupport5gBand(supportBand5g).build();
60
61        collector.checkThat("mClusterHigh", clusterHigh, equalTo(configRequest.mClusterHigh));
62        collector.checkThat("mClusterLow", clusterLow, equalTo(configRequest.mClusterLow));
63        collector.checkThat("mMasterPreference", masterPreference,
64                equalTo(configRequest.mMasterPreference));
65        collector.checkThat("mSupport5gBand", supportBand5g, equalTo(configRequest.mSupport5gBand));
66    }
67
68    @Test
69    public void testConfigRequestBuilderMasterPrefNegative() {
70        thrown.expect(IllegalArgumentException.class);
71        ConfigRequest.Builder builder = new ConfigRequest.Builder();
72        builder.setMasterPreference(-1);
73    }
74
75    @Test
76    public void testConfigRequestBuilderMasterPrefReserved1() {
77        thrown.expect(IllegalArgumentException.class);
78        new ConfigRequest.Builder().setMasterPreference(1);
79    }
80
81    @Test
82    public void testConfigRequestBuilderMasterPrefReserved255() {
83        thrown.expect(IllegalArgumentException.class);
84        new ConfigRequest.Builder().setMasterPreference(255);
85    }
86
87    @Test
88    public void testConfigRequestBuilderMasterPrefTooLarge() {
89        thrown.expect(IllegalArgumentException.class);
90        new ConfigRequest.Builder().setMasterPreference(256);
91    }
92
93    @Test
94    public void testConfigRequestBuilderClusterLowNegative() {
95        thrown.expect(IllegalArgumentException.class);
96        new ConfigRequest.Builder().setClusterLow(-1);
97    }
98
99    @Test
100    public void testConfigRequestBuilderClusterHighNegative() {
101        thrown.expect(IllegalArgumentException.class);
102        new ConfigRequest.Builder().setClusterHigh(-1);
103    }
104
105    @Test
106    public void testConfigRequestBuilderClusterLowAboveMax() {
107        thrown.expect(IllegalArgumentException.class);
108        new ConfigRequest.Builder().setClusterLow(ConfigRequest.CLUSTER_ID_MAX + 1);
109    }
110
111    @Test
112    public void testConfigRequestBuilderClusterHighAboveMax() {
113        thrown.expect(IllegalArgumentException.class);
114        new ConfigRequest.Builder().setClusterHigh(ConfigRequest.CLUSTER_ID_MAX + 1);
115    }
116
117    @Test
118    public void testConfigRequestBuilderClusterLowLargerThanHigh() {
119        thrown.expect(IllegalArgumentException.class);
120        ConfigRequest configRequest = new ConfigRequest.Builder().setClusterLow(100)
121                .setClusterHigh(5).build();
122    }
123
124    @Test
125    public void testConfigRequestParcel() {
126        final int clusterHigh = 189;
127        final int clusterLow = 25;
128        final int masterPreference = 177;
129        final boolean supportBand5g = true;
130
131        ConfigRequest configRequest = new ConfigRequest.Builder().setClusterHigh(clusterHigh)
132                .setClusterLow(clusterLow).setMasterPreference(masterPreference)
133                .setSupport5gBand(supportBand5g).build();
134
135        Parcel parcelW = Parcel.obtain();
136        configRequest.writeToParcel(parcelW, 0);
137        byte[] bytes = parcelW.marshall();
138        parcelW.recycle();
139
140        Parcel parcelR = Parcel.obtain();
141        parcelR.unmarshall(bytes, 0, bytes.length);
142        parcelR.setDataPosition(0);
143        ConfigRequest rereadConfigRequest = ConfigRequest.CREATOR.createFromParcel(parcelR);
144
145        assertEquals(configRequest, rereadConfigRequest);
146    }
147
148    /*
149     * SubscribeData Tests
150     */
151
152    @Test
153    public void testSubscribeDataBuilder() {
154        final String serviceName = "some_service_or_other";
155        final String serviceSpecificInfo = "long arbitrary string with some info";
156        final byte[] txFilter = {
157                0, 1, 16, 1, 22 };
158        final byte[] rxFilter = {
159                1, 127, 0, 1, -5, 1, 22 };
160
161        SubscribeData subscribeData = new SubscribeData.Builder().setServiceName(serviceName)
162                .setServiceSpecificInfo(serviceSpecificInfo).setTxFilter(txFilter, txFilter.length)
163                .setRxFilter(rxFilter, rxFilter.length).build();
164
165        collector.checkThat("mServiceName", serviceName, equalTo(subscribeData.mServiceName));
166        String mServiceSpecificInfo = new String(subscribeData.mServiceSpecificInfo, 0,
167                subscribeData.mServiceSpecificInfoLength);
168        collector.checkThat("mServiceSpecificInfo",
169                utilAreArraysEqual(serviceSpecificInfo.getBytes(), serviceSpecificInfo.length(),
170                        subscribeData.mServiceSpecificInfo,
171                        subscribeData.mServiceSpecificInfoLength),
172                equalTo(true));
173        collector.checkThat("mTxFilter", utilAreArraysEqual(txFilter, txFilter.length,
174                subscribeData.mTxFilter, subscribeData.mTxFilterLength), equalTo(true));
175        collector.checkThat("mRxFilter", utilAreArraysEqual(rxFilter, rxFilter.length,
176                subscribeData.mRxFilter, subscribeData.mRxFilterLength), equalTo(true));
177    }
178
179    @Test
180    public void testSubscribeDataParcel() {
181        final String serviceName = "some_service_or_other";
182        final String serviceSpecificInfo = "long arbitrary string with some info";
183        final byte[] txFilter = {
184                0, 1, 16, 1, 22 };
185        final byte[] rxFilter = {
186                1, 127, 0, 1, -5, 1, 22 };
187
188        SubscribeData subscribeData = new SubscribeData.Builder().setServiceName(serviceName)
189                .setServiceSpecificInfo(serviceSpecificInfo).setTxFilter(txFilter, txFilter.length)
190                .setTxFilter(rxFilter, rxFilter.length).build();
191
192        Parcel parcelW = Parcel.obtain();
193        subscribeData.writeToParcel(parcelW, 0);
194        byte[] bytes = parcelW.marshall();
195        parcelW.recycle();
196
197        Parcel parcelR = Parcel.obtain();
198        parcelR.unmarshall(bytes, 0, bytes.length);
199        parcelR.setDataPosition(0);
200        SubscribeData rereadSubscribeData = SubscribeData.CREATOR.createFromParcel(parcelR);
201
202        assertEquals(subscribeData, rereadSubscribeData);
203    }
204
205    /*
206     * SubscribeSettings Tests
207     */
208
209    @Test
210    public void testSubscribeSettingsBuilder() {
211        final int subscribeType = SubscribeSettings.SUBSCRIBE_TYPE_PASSIVE;
212        final int subscribeCount = 10;
213        final int subscribeTtl = 15;
214
215        SubscribeSettings subscribeSetting = new SubscribeSettings.Builder()
216                .setSubscribeType(subscribeType).setSubscribeCount(subscribeCount)
217                .setTtlSec(subscribeTtl).build();
218
219        collector.checkThat("mSubscribeType", subscribeType,
220                equalTo(subscribeSetting.mSubscribeType));
221        collector.checkThat("mSubscribeCount", subscribeCount,
222                equalTo(subscribeSetting.mSubscribeCount));
223        collector.checkThat("mTtlSec", subscribeTtl, equalTo(subscribeSetting.mTtlSec));
224    }
225
226    @Test
227    public void testSubscribeSettingsBuilderBadSubscribeType() {
228        thrown.expect(IllegalArgumentException.class);
229        new SubscribeSettings.Builder().setSubscribeType(10);
230    }
231
232    @Test
233    public void testSubscribeSettingsBuilderNegativeCount() {
234        thrown.expect(IllegalArgumentException.class);
235        new SubscribeSettings.Builder().setSubscribeCount(-1);
236    }
237
238    @Test
239    public void testSubscribeSettingsBuilderNegativeTtl() {
240        thrown.expect(IllegalArgumentException.class);
241        new SubscribeSettings.Builder().setTtlSec(-100);
242    }
243
244    @Test
245    public void testSubscribeSettingsParcel() {
246        final int subscribeType = SubscribeSettings.SUBSCRIBE_TYPE_PASSIVE;
247        final int subscribeCount = 10;
248        final int subscribeTtl = 15;
249
250        SubscribeSettings subscribeSetting = new SubscribeSettings.Builder()
251                .setSubscribeType(subscribeType).setSubscribeCount(subscribeCount)
252                .setTtlSec(subscribeTtl).build();
253
254        Parcel parcelW = Parcel.obtain();
255        subscribeSetting.writeToParcel(parcelW, 0);
256        byte[] bytes = parcelW.marshall();
257        parcelW.recycle();
258
259        Parcel parcelR = Parcel.obtain();
260        parcelR.unmarshall(bytes, 0, bytes.length);
261        parcelR.setDataPosition(0);
262        SubscribeSettings rereadSubscribeSettings = SubscribeSettings.CREATOR
263                .createFromParcel(parcelR);
264
265        assertEquals(subscribeSetting, rereadSubscribeSettings);
266    }
267
268    /*
269     * PublishData Tests
270     */
271
272    @Test
273    public void testPublishDataBuilder() {
274        final String serviceName = "some_service_or_other";
275        final String serviceSpecificInfo = "long arbitrary string with some info";
276        final byte[] txFilter = {
277                0, 1, 16, 1, 22 };
278        final byte[] rxFilter = {
279                1, 127, 0, 1, -5, 1, 22 };
280
281        PublishData publishData = new PublishData.Builder().setServiceName(serviceName)
282                .setServiceSpecificInfo(serviceSpecificInfo).setTxFilter(txFilter, txFilter.length)
283                .setRxFilter(rxFilter, rxFilter.length).build();
284
285        collector.checkThat("mServiceName", serviceName, equalTo(publishData.mServiceName));
286        String mServiceSpecificInfo = new String(publishData.mServiceSpecificInfo, 0,
287                publishData.mServiceSpecificInfoLength);
288        collector.checkThat("mServiceSpecificInfo",
289                utilAreArraysEqual(serviceSpecificInfo.getBytes(), serviceSpecificInfo.length(),
290                        publishData.mServiceSpecificInfo, publishData.mServiceSpecificInfoLength),
291                equalTo(true));
292        collector.checkThat("mTxFilter", utilAreArraysEqual(txFilter, txFilter.length,
293                publishData.mTxFilter, publishData.mTxFilterLength), equalTo(true));
294        collector.checkThat("mRxFilter", utilAreArraysEqual(rxFilter, rxFilter.length,
295                publishData.mRxFilter, publishData.mRxFilterLength), equalTo(true));
296    }
297
298    @Test
299    public void testPublishDataParcel() {
300        final String serviceName = "some_service_or_other";
301        final String serviceSpecificInfo = "long arbitrary string with some info";
302        final byte[] txFilter = {
303                0, 1, 16, 1, 22 };
304        final byte[] rxFilter = {
305                1, 127, 0, 1, -5, 1, 22 };
306
307        PublishData publishData = new PublishData.Builder().setServiceName(serviceName)
308                .setServiceSpecificInfo(serviceSpecificInfo).setTxFilter(txFilter, txFilter.length)
309                .setTxFilter(rxFilter, rxFilter.length).build();
310
311        Parcel parcelW = Parcel.obtain();
312        publishData.writeToParcel(parcelW, 0);
313        byte[] bytes = parcelW.marshall();
314        parcelW.recycle();
315
316        Parcel parcelR = Parcel.obtain();
317        parcelR.unmarshall(bytes, 0, bytes.length);
318        parcelR.setDataPosition(0);
319        PublishData rereadPublishData = PublishData.CREATOR.createFromParcel(parcelR);
320
321        assertEquals(publishData, rereadPublishData);
322    }
323
324    /*
325     * PublishSettings Tests
326     */
327
328    @Test
329    public void testPublishSettingsBuilder() {
330        final int publishType = PublishSettings.PUBLISH_TYPE_SOLICITED;
331        final int publishCount = 10;
332        final int publishTtl = 15;
333
334        PublishSettings publishSetting = new PublishSettings.Builder().setPublishType(publishType)
335                .setPublishCount(publishCount).setTtlSec(publishTtl).build();
336
337        collector.checkThat("mPublishType", publishType, equalTo(publishSetting.mPublishType));
338        collector.checkThat("mPublishCount", publishCount, equalTo(publishSetting.mPublishCount));
339        collector.checkThat("mTtlSec", publishTtl, equalTo(publishSetting.mTtlSec));
340    }
341
342    @Test
343    public void testPublishSettingsBuilderBadPublishType() {
344        thrown.expect(IllegalArgumentException.class);
345        new PublishSettings.Builder().setPublishType(5);
346    }
347
348    @Test
349    public void testPublishSettingsBuilderNegativeCount() {
350        thrown.expect(IllegalArgumentException.class);
351        new PublishSettings.Builder().setPublishCount(-4);
352    }
353
354    @Test
355    public void testPublishSettingsBuilderNegativeTtl() {
356        thrown.expect(IllegalArgumentException.class);
357        new PublishSettings.Builder().setTtlSec(-10);
358    }
359
360    @Test
361    public void testPublishSettingsParcel() {
362        final int publishType = PublishSettings.PUBLISH_TYPE_SOLICITED;
363        final int publishCount = 10;
364        final int publishTtl = 15;
365
366        PublishSettings configSetting = new PublishSettings.Builder().setPublishType(publishType)
367                .setPublishCount(publishCount).setTtlSec(publishTtl).build();
368
369        Parcel parcelW = Parcel.obtain();
370        configSetting.writeToParcel(parcelW, 0);
371        byte[] bytes = parcelW.marshall();
372        parcelW.recycle();
373
374        Parcel parcelR = Parcel.obtain();
375        parcelR.unmarshall(bytes, 0, bytes.length);
376        parcelR.setDataPosition(0);
377        PublishSettings rereadPublishSettings = PublishSettings.CREATOR.createFromParcel(parcelR);
378
379        assertEquals(configSetting, rereadPublishSettings);
380    }
381
382    /*
383     * Utilities
384     */
385
386    private static boolean utilAreArraysEqual(byte[] x, int xLength, byte[] y, int yLength) {
387        if (xLength != yLength) {
388            return false;
389        }
390
391        if (x != null && y != null) {
392            for (int i = 0; i < xLength; ++i) {
393                if (x[i] != y[i]) {
394                    return false;
395                }
396            }
397        } else if (xLength != 0) {
398            return false; // invalid != invalid
399        }
400
401        return true;
402    }
403}
404