ScoredNetworkTest.java revision 4efd1ca53643c9608700d32da05504a315821d7d 
1/*
2 t 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 android.net;
18
19import static org.junit.Assert.*;
20
21import android.os.Bundle;
22import android.os.Parcel;
23import android.support.test.runner.AndroidJUnit4;
24
25import org.junit.Test;
26import org.junit.runner.RunWith;
27
28import java.util.Arrays;
29
30/** Unit tests for {@link ScoredNetwork}. */
31@RunWith(AndroidJUnit4.class)
32public class ScoredNetworkTest {
33
34    private static final int RSSI_START = -110;
35    private static final int TEST_RSSI = -50;
36    private static final byte TEST_SCORE = 5;
37    private static final RssiCurve CURVE =
38            new RssiCurve(RSSI_START, 10, new byte[] {-1, 0, 1, 2, 3, 4, TEST_SCORE, 6, 7});
39
40    private static final byte RANKING_SCORE_OFFSET = 13;
41    private static final Bundle ATTRIBUTES;
42    static {
43        ATTRIBUTES = new Bundle();
44        ATTRIBUTES.putInt(
45                ScoredNetwork.ATTRIBUTES_KEY_RANKING_SCORE_OFFSET, RANKING_SCORE_OFFSET);
46    }
47
48    private static final NetworkKey KEY
49        = new NetworkKey(new WifiKey("\"ssid\"", "00:00:00:00:00:00"));
50
51    @Test
52    public void scoredNetworksWithBothNullAttributeBundle_equal() {
53        ScoredNetwork scoredNetwork1 =
54                new ScoredNetwork(KEY, CURVE, false /* meteredHint */, null /* attributes */);
55        ScoredNetwork scoredNetwork2 =
56                new ScoredNetwork(KEY, CURVE, false /* meteredHint */, null /* attributes */);
57        assertTrue(scoredNetwork1.equals(scoredNetwork2));
58    }
59
60    @Test
61    public void scoredNetworksWithOneNullAttributeBundle_notEqual() {
62        ScoredNetwork scoredNetwork1 =
63                new ScoredNetwork(KEY, CURVE, false /* meteredHint */, ATTRIBUTES);
64        ScoredNetwork scoredNetwork2 =
65                new ScoredNetwork(KEY, CURVE, false /* meteredHint */, null /* attributes */);
66        assertFalse(scoredNetwork1.equals(scoredNetwork2));
67    }
68
69    @Test
70    public void scoredNetworksWithDifferentSizedAttributeBundle_notEqual() {
71        ScoredNetwork scoredNetwork1 =
72                new ScoredNetwork(KEY, CURVE, false /* meteredHint */, ATTRIBUTES);
73        Bundle attr = new Bundle(ATTRIBUTES);
74        attr.putBoolean(ScoredNetwork.ATTRIBUTES_KEY_HAS_CAPTIVE_PORTAL, true);
75        ScoredNetwork scoredNetwork2 =
76                new ScoredNetwork(KEY, CURVE, false /* meteredHint */, attr);
77        assertFalse(scoredNetwork1.equals(scoredNetwork2));
78    }
79
80    @Test
81    public void scoredNetworksWithDifferentAttributeValues_notEqual() {
82        ScoredNetwork scoredNetwork1 =
83                new ScoredNetwork(KEY, CURVE, false /* meteredHint */, ATTRIBUTES);
84        Bundle attr = new Bundle();
85        attr.putInt(ScoredNetwork.ATTRIBUTES_KEY_RANKING_SCORE_OFFSET, Integer.MIN_VALUE);
86        ScoredNetwork scoredNetwork2 =
87                new ScoredNetwork(KEY, CURVE, false /* meteredHint */, attr);
88        assertFalse(scoredNetwork1.equals(scoredNetwork2));
89    }
90
91    @Test
92    public void scoredNetworksWithSameAttributeValuesAndSize_equal() {
93        ScoredNetwork scoredNetwork1 =
94                new ScoredNetwork(KEY, CURVE, false /* meteredHint */, ATTRIBUTES);
95        ScoredNetwork scoredNetwork2 =
96                new ScoredNetwork(KEY, CURVE, false /* meteredHint */, ATTRIBUTES);
97        assertTrue(scoredNetwork1.equals(scoredNetwork2));
98    }
99
100    @Test
101    public void calculateRankingOffsetShouldThrowUnsupportedOperationException() {
102        // No curve or ranking score offset set in curve
103        ScoredNetwork scoredNetwork = new ScoredNetwork(KEY, null);
104        try {
105            scoredNetwork.calculateRankingScore(TEST_RSSI);
106            fail("Should have thrown UnsupportedOperationException");
107        } catch (UnsupportedOperationException e) {
108            // expected
109        }
110    }
111
112    @Test
113    public void calculateRankingOffsetWithRssiCurveShouldReturnExpectedScore() {
114        ScoredNetwork scoredNetwork = new ScoredNetwork(KEY, CURVE);
115        assertEquals(TEST_SCORE << Byte.SIZE, scoredNetwork.calculateRankingScore(TEST_RSSI));
116    }
117
118    @Test
119    public void rankingScoresShouldDifferByRankingScoreOffset() {
120        ScoredNetwork scoredNetwork1 = new ScoredNetwork(KEY, CURVE);
121        ScoredNetwork scoredNetwork2
122            = new ScoredNetwork(KEY, CURVE, false /* meteredHint */, ATTRIBUTES);
123        int scoreDifference =
124            scoredNetwork2.calculateRankingScore(TEST_RSSI)
125            - scoredNetwork1.calculateRankingScore(TEST_RSSI);
126        assertEquals(RANKING_SCORE_OFFSET, scoreDifference);
127    }
128
129    @Test
130    public void calculateRankingScoreShouldNotResultInIntegerOverflow() {
131        Bundle attr = new Bundle();
132        attr.putInt(ScoredNetwork.ATTRIBUTES_KEY_RANKING_SCORE_OFFSET, Integer.MAX_VALUE);
133        ScoredNetwork scoredNetwork
134            = new ScoredNetwork(KEY, CURVE, false /* meteredHint */, attr);
135        assertEquals(Integer.MAX_VALUE, scoredNetwork.calculateRankingScore(TEST_RSSI));
136    }
137
138    @Test
139    public void calculateRankingScoreShouldNotResultInIntegerUnderflow() {
140        Bundle attr = new Bundle();
141        attr.putInt(ScoredNetwork.ATTRIBUTES_KEY_RANKING_SCORE_OFFSET, Integer.MIN_VALUE);
142        ScoredNetwork scoredNetwork =
143                new ScoredNetwork(KEY, CURVE, false /* meteredHint */, attr);
144        assertEquals(Integer.MIN_VALUE, scoredNetwork.calculateRankingScore(RSSI_START));
145    }
146
147    @Test
148    public void hasRankingScoreShouldReturnFalse() {
149        ScoredNetwork network = new ScoredNetwork(KEY, null /* rssiCurve */);
150        assertFalse(network.hasRankingScore());
151    }
152
153    @Test
154    public void hasRankingScoreShouldReturnTrueWhenAttributesHasRankingScoreOffset() {
155        ScoredNetwork network =
156                new ScoredNetwork(KEY, null /* rssiCurve */, false /* meteredHint */, ATTRIBUTES);
157        assertTrue(network.hasRankingScore());
158    }
159
160    @Test
161    public void hasRankingScoreShouldReturnTrueWhenCurveIsPresent() {
162        ScoredNetwork network =
163                new ScoredNetwork(KEY, CURVE , false /* meteredHint */);
164        assertTrue(network.hasRankingScore());
165    }
166
167    @Test
168    public void shouldWriteAndReadFromParcelWhenAllFieldsSet() {
169        ScoredNetwork network = new ScoredNetwork(KEY, CURVE, true /* meteredHint */, ATTRIBUTES);
170        ScoredNetwork newNetwork;
171
172        Parcel parcel = null;
173        try {
174            parcel = Parcel.obtain();
175            network.writeToParcel(parcel, 0 /* flags */);
176            parcel.setDataPosition(0);
177            newNetwork = ScoredNetwork.CREATOR.createFromParcel(parcel);
178        } finally {
179            if (parcel != null) {
180                parcel.recycle();
181            }
182        }
183        assertEquals(CURVE.start, newNetwork.rssiCurve.start);
184        assertEquals(CURVE.bucketWidth, newNetwork.rssiCurve.bucketWidth);
185        assertTrue(Arrays.equals(CURVE.rssiBuckets, newNetwork.rssiCurve.rssiBuckets));
186        assertTrue(newNetwork.meteredHint);
187        assertNotNull(newNetwork.attributes);
188        assertEquals(
189                RANKING_SCORE_OFFSET,
190                newNetwork.attributes.getInt(ScoredNetwork.ATTRIBUTES_KEY_RANKING_SCORE_OFFSET));
191    }
192
193    @Test
194    public void shouldWriteAndReadFromParcelWithoutBundle() {
195        ScoredNetwork network = new ScoredNetwork(KEY, CURVE, true /* meteredHint */);
196        ScoredNetwork newNetwork;
197
198        Parcel parcel = null;
199        try {
200            parcel = Parcel.obtain();
201            network.writeToParcel(parcel, 0 /* flags */);
202            parcel.setDataPosition(0);
203            newNetwork = ScoredNetwork.CREATOR.createFromParcel(parcel);
204        } finally {
205            if (parcel != null) {
206                parcel.recycle();
207            }
208        }
209        assertEquals(CURVE.start, newNetwork.rssiCurve.start);
210        assertEquals(CURVE.bucketWidth, newNetwork.rssiCurve.bucketWidth);
211        assertTrue(Arrays.equals(CURVE.rssiBuckets, newNetwork.rssiCurve.rssiBuckets));
212        assertTrue(newNetwork.meteredHint);
213        assertNull(newNetwork.attributes);
214    }
215
216    @Test
217    public void calculateBadgeShouldReturnNoBadgeWhenNoAttributesBundle() {
218        ScoredNetwork network = new ScoredNetwork(KEY, CURVE);
219        assertEquals(NetworkBadging.BADGING_NONE, network.calculateBadge(TEST_RSSI));
220    }
221
222    @Test
223    public void calculateBadgeShouldReturnNoBadgeWhenNoBadgingCurveInBundle() {
224        ScoredNetwork network = new ScoredNetwork(KEY, CURVE, false /* meteredHint */, ATTRIBUTES);
225        assertEquals(NetworkBadging.BADGING_NONE, network.calculateBadge(TEST_RSSI));
226    }
227
228    @Test
229    public void calculateBadgeShouldReturn4kBadge() {
230        ScoredNetwork network =
231            buildScoredNetworkWithGivenBadgeForTestRssi(NetworkBadging.BADGING_4K);
232        assertEquals(NetworkBadging.BADGING_4K, network.calculateBadge(TEST_RSSI));
233    }
234
235    @Test
236    public void calculateBadgeShouldReturnHdBadge() {
237        ScoredNetwork network =
238            buildScoredNetworkWithGivenBadgeForTestRssi(NetworkBadging.BADGING_HD);
239        assertEquals(NetworkBadging.BADGING_HD, network.calculateBadge(TEST_RSSI));
240    }
241
242    @Test
243    public void calculateBadgeShouldReturnSdBadge() {
244        ScoredNetwork network =
245            buildScoredNetworkWithGivenBadgeForTestRssi(NetworkBadging.BADGING_SD);
246        assertEquals(NetworkBadging.BADGING_SD, network.calculateBadge(TEST_RSSI));
247    }
248
249    @Test
250    public void calculateBadgeShouldReturnNoBadge() {
251        ScoredNetwork network =
252            buildScoredNetworkWithGivenBadgeForTestRssi(NetworkBadging.BADGING_NONE);
253        assertEquals(NetworkBadging.BADGING_NONE, network.calculateBadge(TEST_RSSI));
254    }
255
256    private ScoredNetwork buildScoredNetworkWithGivenBadgeForTestRssi(int badge) {
257        RssiCurve badgingCurve =
258               new RssiCurve(RSSI_START, 10, new byte[] {0, 0, 0, 0, 0, 0, (byte) badge});
259        Bundle attr = new Bundle();
260        attr.putParcelable(ScoredNetwork.ATTRIBUTES_KEY_BADGING_CURVE, badgingCurve);
261        return new ScoredNetwork(KEY, CURVE, false /* meteredHint */, attr);
262    }
263}
264